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 java.util.function.*;
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 java.awt.geom.*;
import javax.imageio.*;
import java.math.*;
import java.time.Duration;
import x30_pkg.x30_util;
import static x30_pkg.x30_util.VF1;
import static x30_pkg.x30_util.l;
import static x30_pkg.x30_util.getOpt;
import static x30_pkg.x30_util.setOpt;
import static x30_pkg.x30_util.callOpt;
import static x30_pkg.x30_util.newWeakHashMap;
import static x30_pkg.x30_util.newDangerousWeakHashMap;
import static x30_pkg.x30_util.get;
import static x30_pkg.x30_util.assertTrue;
import static x30_pkg.x30_util.isHeadless;
import static x30_pkg.x30_util.isAndroid;
import static x30_pkg.x30_util.isTrue;
import x30_pkg.x30_util.DynamicObject;
import loadableUtils.utils;
import static loadableUtils.utils._threadInfo;
import static loadableUtils.utils._threadInheritInfo;
import static loadableUtils.utils.match;
import static loadableUtils.utils.setOpt_raw;
import static loadableUtils.utils.getField;
import static loadableUtils.utils.format3;
import static loadableUtils.utils.vm_generalIdentityHashSet;
import static loadableUtils.utils.vm_generalHashMap;
import static loadableUtils.utils.vm_generalWeakSubMap;
import static loadableUtils.utils.bindToComponent;
import static loadableUtils.utils.struct;
import static loadableUtils.utils.structure;
import static loadableUtils.utils.loadPage;
import static loadableUtils.utils.loadPageSilently;
import static loadableUtils.utils.loadSnippet;
import static loadableUtils.utils.componentPopupMenu;
import static loadableUtils.utils.dm_current_generic;
import static loadableUtils.utils.cset;
import static loadableUtils.utils.DynamicObject_loading;
import static loadableUtils.utils.concepts_unlisted;
import static loadableUtils.utils.dynamicObjectIsLoading;
import static loadableUtils.utils.rethrow;
import static loadableUtils.utils.realMC_tl;
import loadableUtils.utils.F0;
import loadableUtils.utils.F1;
import loadableUtils.utils.IF0;
import loadableUtils.utils.IF1;
import loadableUtils.utils.IVF1;
import loadableUtils.utils.IVF2;
import loadableUtils.utils.Matches;
import loadableUtils.utils.BetterLabel;
import loadableUtils.utils.SingleComponentPanel;
import loadableUtils.utils.Q;
import loadableUtils.utils.ImageSurface;
import loadableUtils.utils.structure_Data;
import loadableUtils.utils.RGBImage;
import loadableUtils.utils.RGB;
import loadableUtils.utils.MakesBufferedImage;
import loadableUtils.utils.MultiSet;
import loadableUtils.utils.Concept;
import loadableUtils.utils.Concepts;
import loadableUtils.utils.RC;
import loadableUtils.utils.IterableIterator;
import loadableUtils.utils.IFieldIndex;
import loadableUtils.utils.Swingable;
import loadableUtils.utils.PersistableThrowable;
import loadableUtils.utils.DynPrintLog;
import loadableUtils.utils.GlobalID;
import loadableUtils.utils.Rect;
import loadableUtils.utils.Pt;
import java.awt.geom.*;
import org.apache.bcel.classfile.JavaClass;
import org.apache.bcel.Const;
import org.apache.bcel.generic.*;
import java.lang.reflect.Type;
import java.nio.file.*;
import static java.nio.file.StandardWatchEventKinds.*;
import org.fife.ui.rsyntaxtextarea.RSyntaxDocument;
import org.fife.ui.autocomplete.*;
import org.fife.rsta.ui.CollapsibleSectionPanel;
import org.fife.rsta.ui.GoToDialog;
import org.fife.rsta.ui.SizeGripIcon;
import org.fife.rsta.ui.search.FindDialog;
import org.fife.rsta.ui.search.ReplaceDialog;
import org.fife.rsta.ui.search.ReplaceToolBar;
import org.fife.rsta.ui.search.SearchEvent;
import org.fife.rsta.ui.search.SearchListener;
import org.fife.rsta.ui.search.FindToolBar;
import org.fife.ui.rsyntaxtextarea.ErrorStrip;
import org.fife.ui.rsyntaxtextarea.RSyntaxTextArea;
import org.fife.ui.rsyntaxtextarea.SyntaxConstants;
import org.fife.ui.rtextarea.RTextScrollPane;
import org.fife.ui.rtextarea.SearchContext;
import org.fife.ui.rtextarea.SearchEngine;
import org.fife.ui.rtextarea.SearchResult;
import org.fife.ui.rsyntaxtextarea.SyntaxScheme;
import java.util.jar.*;
import java.text.*;
import javax.swing.border.TitledBorder;
import org.fife.ui.rsyntaxtextarea.*;
import java.awt.datatransfer.StringSelection;
import javax.swing.undo.UndoManager;
import javax.swing.border.*;
import java.text.NumberFormat;
import java.nio.charset.Charset;
import javax.swing.event.AncestorListener;
import javax.swing.event.AncestorEvent;
import javax.swing.Timer;
import java.util.TimeZone;
import javax.imageio.metadata.*;
import javax.imageio.stream.*;
import java.text.SimpleDateFormat;

public class main {

  static public class AModule extends DynPrintLog {

    public void start() {
      try {
        super.start();
        startThread("Start", new Runnable() {

          public void run() {
            try {
              AutoCloseable __10 = enter();
              try {
                try {
                  test_leftArrowScript_comma();
                } catch (Throwable __e) {
                  printStackTrace(__e);
                }
              } finally {
                _close(__10);
              }
            } catch (Exception __e) {
              throw rethrow(__e);
            }
          }

          public String toString() {
            return "AutoCloseable __10 = enter(); try { try {\r\n    test_leftArrowScript_comma();\r...";
          }
        });
      } catch (Exception __e) {
        throw rethrow(__e);
      }
    }
  }

  static public boolean _moduleClass_AModule = true;

  static public String programID;

  static public void _onLoad_initUtils() {
    utils.__javax = javax();
  }

  static public void _onLoad_defaultClassFinder() {
    setDefaultClassFinder(new F1<String, Class>() {

      public Class get(String name) {
        Class c = findClass_fullName(name);
        if (c != null)
          return c;
        if (name.startsWith("main$"))
          return loadableUtils.utils.findClass_fullName("loadableUtils.utils" + name.substring(4));
        return null;
      }
    });
  }

  static public ThreadLocal<Boolean> dynamicObjectIsLoading_threadLocal() {
    return DynamicObject_loading;
  }

  static volatile public Concepts mainConcepts;

  static public Concepts db_mainConcepts() {
    if (mainConcepts == null)
      mainConcepts = newConceptsWithClassFinder(getDBProgramID());
    return mainConcepts;
  }

  static public void cleanMeUp_concepts() {
    if (db_mainConcepts() != null)
      db_mainConcepts().cleanMeUp();
  }

  static public Thread startThread(Object runnable) {
    return startThread(defaultThreadName(), runnable);
  }

  static public Thread startThread(String name, Runnable runnable) {
    runnable = wrapAsActivity(runnable);
    return startThread(newThread(runnable, name));
  }

  static public Thread startThread(String name, Object runnable) {
    runnable = wrapAsActivity(runnable);
    return startThread(newThread(toRunnable(runnable), name));
  }

  static public Thread startThread(Thread t) {
    _registerThread(t);
    t.start();
    return t;
  }

  static public void test_leftArrowScript_comma() {
    new TestFunctionValues<String, Object>(__1 -> leftArrowVerbose(__1)).io(" new Pair 1 2, a ", 1).run();
  }

  static public <A extends Throwable> A printStackTrace(A e) {
    if (e != null)
      print(getStackTrace(e));
    return e;
  }

  static public void printStackTrace() {
    printStackTrace(new Throwable());
  }

  static public void printStackTrace(String msg) {
    printStackTrace(new Throwable(msg));
  }

  static public void printStackTrace(String msg, Throwable e) {
    printStackTrace(new Throwable(msg, e));
  }

  static public void _close(AutoCloseable c) {
    if (c != null)
      try {
        c.close();
      } catch (Throwable e) {
        if (c instanceof javax.imageio.stream.ImageOutputStream)
          return;
        else
          throw rethrow(e);
      }
  }

  static public Class javax() {
    return getJavaX();
  }

  static public void setDefaultClassFinder(Object cf) {
    _defaultClassFinder_value = cf;
  }

  static public HashMap<String, Class> findClass_fullName_cache = new HashMap();

  static public Class findClass_fullName(String name) {
    synchronized (findClass_fullName_cache) {
      if (findClass_fullName_cache.containsKey(name))
        return findClass_fullName_cache.get(name);
      Class c;
      try {
        c = Class.forName(name);
      } catch (ClassNotFoundException e) {
        c = null;
      }
      findClass_fullName_cache.put(name, c);
      return c;
    }
  }

  static public Object _defaultClassFinder_value = defaultDefaultClassFinder();

  static public Object _defaultClassFinder() {
    return _defaultClassFinder_value;
  }

  static public Concepts newConceptsWithClassFinder(String progID) {
    Concepts cc = new Concepts(progID);
    cc.classFinder = _defaultClassFinder();
    return cc;
  }

  static public Concepts newConceptsWithClassFinder(File conceptsFile) {
    Concepts cc = new Concepts(assertNotNull(conceptsFile));
    cc.classFinder = _defaultClassFinder();
    return cc;
  }

  static public Concepts newConceptsWithClassFinder(File conceptsFile, IF1<String, Class> classFinder) {
    Concepts cc = new Concepts(assertNotNull(conceptsFile));
    cc.classFinder = classFinder;
    return cc;
  }

  static public String getDBProgramID_id;

  static public String getDBProgramID() {
    return nempty(getDBProgramID_id) ? getDBProgramID_id : programIDWithCase();
  }

  static public String defaultThreadName_name;

  static public String defaultThreadName() {
    if (defaultThreadName_name == null)
      defaultThreadName_name = "A thread by " + programID();
    return defaultThreadName_name;
  }

  static public Runnable wrapAsActivity(Object r) {
    if (r == null)
      return null;
    Runnable r2 = toRunnable(r);
    Object mod = dm_current_generic();
    if (mod == null)
      return r2;
    return new Runnable() {

      public void run() {
        try {
          AutoCloseable c = (AutoCloseable) (rcall("enter", mod));
          AutoCloseable __1 = c;
          try {
            r2.run();
          } finally {
            _close(__1);
          }
        } catch (Exception __e) {
          throw rethrow(__e);
        }
      }

      public String toString() {
        return "AutoCloseable c =  (AutoCloseable) (rcall enter(mod));\r\n    temp c;\r\n    r2.r...";
      }
    };
  }

  static public Thread newThread(Object runnable) {
    return new BetterThread(_topLevelErrorHandling(toRunnable(runnable)));
  }

  static public Thread newThread(Object runnable, String name) {
    if (name == null)
      name = defaultThreadName();
    return new BetterThread(_topLevelErrorHandling(toRunnable(runnable)), name);
  }

  static public Thread newThread(String name, Object runnable) {
    return newThread(runnable, name);
  }

  static public Runnable toRunnable(final Object o) {
    if (o == null)
      return null;
    if (o instanceof Runnable)
      return (Runnable) o;
    if (o instanceof String)
      throw fail("callF_legacy");
    return new Runnable() {

      public void run() {
        try {
          callF(o);
        } catch (Exception __e) {
          throw rethrow(__e);
        }
      }

      public String toString() {
        return "callF(o)";
      }
    };
  }

  static public Map<Thread, Boolean> _registerThread_threads;

  static public Object _onRegisterThread;

  static public Thread _registerThread(Thread t) {
    if (_registerThread_threads == null)
      _registerThread_threads = newWeakHashMap();
    _registerThread_threads.put(t, true);
    vm_generalWeakSubMap("thread2mc").put(t, weakRef(mc()));
    callF(_onRegisterThread, t);
    return t;
  }

  static public void _registerThread() {
    _registerThread(Thread.currentThread());
  }

  static public Object leftArrowVerbose(LASClassLoader lasClassLoader, String script) {
    GazelleV_LeftArrowScriptParser parser = new GazelleV_LeftArrowScriptParser();
    parser.lasClassLoader(lasClassLoader);
    return leftArrowVerbose(parser, script);
  }

  static public Object leftArrowVerbose(String script) {
    return leftArrowVerbose(new GazelleV_LeftArrowScriptParser(), script);
  }

  static public Object leftArrowVerbose(GazelleV_LeftArrowScriptParser parser, String script) {
    if (parser.lasClassLoader() != null)
      parser.lasClassLoader().rememberClassBytes(true);
    enableScaffolding(parser);
    parser.allowTheWorld();
    var parsedScript = parser.parse(script);
    parser.printFunctionDefs(parsedScript);
    print(parsedScript);
    printIndentedStruct(parsedScript);
    VarContext ctx = new VarContext();
    var result = parsedScript.get(ctx);
    ctx.printMe();
    return result;
  }

  static volatile public StringBuffer local_log = new StringBuffer();

  static public boolean printAlsoToSystemOut = true;

  static volatile public Appendable print_log = local_log;

  static volatile public int print_log_max = 1024 * 1024;

  static volatile public int local_log_max = 100 * 1024;

  static public boolean print_silent = false;

  static public Object print_byThread_lock = new Object();

  static volatile public ThreadLocal<Object> print_byThread;

  static volatile public Object print_allThreads;

  static volatile public Object print_preprocess;

  static public void print() {
    print("");
  }

  static public <A> A print(String s, A o) {
    print(combinePrintParameters(s, o));
    return o;
  }

  static public <A> A print(A o) {
    ping_okInCleanUp();
    if (print_silent)
      return o;
    String s = o + "\n";
    print_noNewLine(s);
    return o;
  }

  static public void print_noNewLine(String s) {
    try {
      Object f = getThreadLocal(print_byThread_dontCreate());
      if (f == null)
        f = print_allThreads;
      if (f != null)
        if (isFalse(f instanceof F1 ? ((F1) f).get(s) : callF(f, s)))
          return;
    } catch (Throwable e) {
      System.out.println(getStackTrace(e));
    }
    print_raw(s);
  }

  static public void print_raw(String s) {
    if (print_preprocess != null)
      s = (String) callF(print_preprocess, s);
    s = fixNewLines(s);
    Appendable loc = local_log;
    Appendable buf = print_log;
    int loc_max = print_log_max;
    if (buf != loc && buf != null) {
      print_append(buf, s, print_log_max);
      loc_max = local_log_max;
    }
    if (loc != null)
      print_append(loc, s, loc_max);
    if (printAlsoToSystemOut)
      System.out.print(s);
    vmBus_send("printed", mc(), s);
  }

  static public void print_autoRotate() {
  }

  static public String getStackTrace(Throwable throwable) {
    lastException(throwable);
    return getStackTrace_noRecord(throwable);
  }

  static public String getStackTrace_noRecord(Throwable throwable) {
    StringWriter writer = new StringWriter();
    throwable.printStackTrace(new PrintWriter(writer));
    return hideCredentials(writer.toString());
  }

  static public String getStackTrace() {
    return getStackTrace_noRecord(new Throwable());
  }

  static public String getStackTrace(String msg) {
    return getStackTrace_noRecord(new Throwable(msg));
  }

  static public Class __javax;

  static public Class getJavaX() {
    try {
      return __javax;
    } catch (Exception __e) {
      throw rethrow(__e);
    }
  }

  static public void __setJavaX(Class j) {
    __javax = j;
    _onJavaXSet();
  }

  static public AutoCloseable tempInterceptPrintIfNotIntercepted(F1<String, Boolean> f) {
    return print_byThread().get() == null ? tempInterceptPrint(f) : null;
  }

  static public Object defaultDefaultClassFinder() {
    return new F1<String, Class>() {

      public Class get(String name) {
        name = replacePrefix("main$main$", "main$", name);
        Class c = get2(name);
        return c;
      }

      public Class get2(String name) {
        if (eq(name, "<main>"))
          return mc();
        {
          Class c = findClass_fullName(name);
          if (c != null)
            return c;
        }
        if (startsWithAny(name, "loadableUtils.utils$", "main$", mcDollar()))
          for (String pkg : ll("loadableUtils.utils$", mcDollar())) {
            String newName = pkg + afterDollar(name);
            {
              Class c = findClass_fullName(newName);
              if (c != null)
                return c;
            }
          }
        return null;
      }
    };
  }

  static public <A> A assertNotNull(A a) {
    assertTrue(a != null);
    return a;
  }

  static public <A> A assertNotNull(String msg, A a) {
    assertTrue(msg, a != null);
    return a;
  }

  static public boolean nempty(Collection c) {
    return !empty(c);
  }

  static public boolean nempty(CharSequence s) {
    return !empty(s);
  }

  static public boolean nempty(Object[] o) {
    return !empty(o);
  }

  static public boolean nempty(byte[] o) {
    return !empty(o);
  }

  static public boolean nempty(int[] o) {
    return !empty(o);
  }

  static public boolean nempty(BitSet bs) {
    return !empty(bs);
  }

  static public boolean nempty(Map m) {
    return !empty(m);
  }

  static public boolean nempty(Iterator i) {
    return i != null && i.hasNext();
  }

  static public boolean nempty(IMultiMap mm) {
    return mm != null && mm.size() != 0;
  }

  static public boolean nempty(Object o) {
    return !empty(o);
  }

  static public boolean nempty(IntRange r) {
    return !empty(r);
  }

  static public boolean nempty(Rect r) {
    return r != null && r.w != 0 && r.h != 0;
  }

  static public boolean nempty(MultiSet ms) {
    return ms != null && !ms.isEmpty();
  }

  static public String programIDWithCase() {
    return nempty(caseID()) ? programID() + "/" + quoteUnlessIdentifierOrInteger(caseID()) : programID();
  }

  static public String programID() {
    return getProgramID();
  }

  static public String programID(Object o) {
    return getProgramID(o);
  }

  static public Object rcall(String method, Object o, Object... args) {
    return call_withVarargs(o, method, args);
  }

  static public Runnable _topLevelErrorHandling(Runnable r) {
    if (r == null)
      return null;
    Object info = _threadInfo();
    Object mod = dm_current_generic();
    Runnable r2 = r;
    if (info != null || mod == null)
      r2 = new Runnable() {

        public void run() {
          try {
            AutoCloseable __1 = (AutoCloseable) (rcall("enter", mod));
            try {
              _threadInheritInfo(info);
              r.run();
            } finally {
              _close(__1);
            }
          } catch (Exception __e) {
            throw rethrow(__e);
          }
        }

        public String toString() {
          return "temp (AutoCloseable) rcall enter(mod);\r\n      _threadInheritInfo(info);\r\n    ...";
        }
      };
    r2 = rPcall(r2);
    return r2;
  }

  static public RuntimeException fail() {
    throw new RuntimeException("fail");
  }

  static public RuntimeException fail(Throwable e) {
    throw asRuntimeException(e);
  }

  static public RuntimeException fail(Object msg) {
    throw new RuntimeException(String.valueOf(msg));
  }

  static public RuntimeException fail(Object... objects) {
    throw new Fail(objects);
  }

  static public RuntimeException fail(String msg) {
    throw new RuntimeException(msg == null ? "" : msg);
  }

  static public RuntimeException fail(String msg, Throwable innerException) {
    throw new RuntimeException(msg, innerException);
  }

  static public Object callF(Object f, Object... args) {
    try {
      if (f instanceof String)
        return callMC((String) f, args);
      return x30_util.callF(f, args);
    } catch (Exception __e) {
      throw rethrow(__e);
    }
  }

  static public <A> A callF(F0<A> f) {
    return f == null ? null : f.get();
  }

  static public <A> A callF(IF0<A> f) {
    return f == null ? null : f.get();
  }

  static public <A, B> B callF(F1<A, B> f, A a) {
    return f == null ? null : f.get(a);
  }

  static public <A, B> B callF(IF1<A, B> f, A a) {
    return f == null ? null : f.get(a);
  }

  static public <A> void callF(VF1<A> f, A a) {
    if (f != null)
      f.get(a);
  }

  static public Object callMC(String method, Object... args) {
    return call(mc(), method, args);
  }

  static public Object call(Object o) {
    return callF(o);
  }

  static public Object call(Object o, String method, Object... args) {
    return call_withVarargs(o, method, args);
  }

  static public <A> WeakReference<A> weakRef(A a) {
    return newWeakReference(a);
  }

  static public Class mc() {
    return main.class;
  }

  static public <A> A enableScaffolding(A o) {
    if (o instanceof IMeta)
      ((IMeta) o).metaPut("scaffolding", true);
    return o;
  }

  static public <A> A printIndentedStruct(A a) {
    return printIndentedStruct("", a);
  }

  static public <A> A printIndentedStruct(String prefix, A a) {
    print(prefix, indentedStructureForUser(a));
    return a;
  }

  static public String combinePrintParameters(String s, Object o) {
    return (endsWithLetterOrDigit(s) ? s + ": " : s) + o;
  }

  static public void ping_okInCleanUp() {
    if (ping_pauseAll || ping_anyActions)
      ping_impl(true);
  }

  static public Object getThreadLocal(Object o, String name) {
    ThreadLocal t = (ThreadLocal) (getOpt(o, name));
    return t != null ? t.get() : null;
  }

  static public <A> A getThreadLocal(ThreadLocal<A> tl) {
    return tl == null ? null : tl.get();
  }

  static public <A> A getThreadLocal(ThreadLocal<A> tl, A defaultValue) {
    return or(getThreadLocal(tl), defaultValue);
  }

  static public ThreadLocal<Object> print_byThread_dontCreate() {
    return print_byThread;
  }

  static public boolean isFalse(Object o) {
    return eq(false, o);
  }

  static public String fixNewLines(String s) {
    int i = indexOf(s, '\r');
    if (i < 0)
      return s;
    int l = s.length();
    StringBuilder out = new StringBuilder(l);
    out.append(s, 0, i);
    for (; i < l; i++) {
      char c = s.charAt(i);
      if (c != '\r')
        out.append(c);
      else {
        out.append('\n');
        if (i + 1 < l && s.charAt(i + 1) == '\n')
          ++i;
      }
    }
    return out.toString();
  }

  static public void print_append(Appendable buf, String s, int max) {
    try {
      synchronized (buf) {
        buf.append(s);
        if (buf instanceof StringBuffer)
          rotateStringBuffer(((StringBuffer) buf), max);
        else if (buf instanceof StringBuilder)
          rotateStringBuilder(((StringBuilder) buf), max);
      }
    } catch (Exception __e) {
      throw rethrow(__e);
    }
  }

  static public void vmBus_send(String msg, Object... args) {
    Object arg = vmBus_wrapArgs(args);
    pcallFAll_minimalExceptionHandling(vm_busListeners_live(), msg, arg);
    pcallFAll_minimalExceptionHandling(vm_busListenersByMessage_live().get(msg), msg, arg);
  }

  static public void vmBus_send(String msg) {
    vmBus_send(msg, (Object) null);
  }

  static volatile public PersistableThrowable lastException_lastException;

  static public PersistableThrowable lastException() {
    return lastException_lastException;
  }

  static public void lastException(Throwable e) {
    lastException_lastException = persistableThrowable(e);
  }

  static public String hideCredentials(URL url) {
    return url == null ? null : hideCredentials(str(url));
  }

  static public String hideCredentials(String url) {
    try {
      if (startsWithOneOf(url, "http://", "https://") && isAGIBlueDomain(hostNameFromURL(url)))
        return url;
    } catch (Throwable e) {
      print("HideCredentials", e);
    }
    return url.replaceAll("([&?])(_pass|key|cookie)=[^&\\s\"]*", "$1$2=<hidden>");
  }

  static public String hideCredentials(Object o) {
    return hideCredentials(str(o));
  }

  static public void _onJavaXSet() {
  }

  static public ThreadLocal<Object> print_byThread() {
    synchronized (print_byThread_lock) {
      if (print_byThread == null)
        print_byThread = new ThreadLocal();
    }
    return print_byThread;
  }

  static public AutoCloseable tempInterceptPrint(F1<String, Boolean> f) {
    return tempSetThreadLocal(print_byThread(), f);
  }

  static public String replacePrefix(String prefix, String replacement, String s) {
    if (!startsWith(s, prefix))
      return s;
    return replacement + substring(s, l(prefix));
  }

  static public Object get2(Object o, String field1, String field2) {
    return get(get(o, field1), field2);
  }

  static public boolean eq(Object a, Object b) {
    return a == b || a != null && b != null && a.equals(b);
  }

  static public boolean eq(Symbol a, String b) {
    return eq(str(a), b);
  }

  static public boolean startsWithAny(String a, Collection<String> b) {
    for (String prefix : unnullForIteration(b)) if (startsWith(a, prefix))
      return true;
    return false;
  }

  static public boolean startsWithAny(String a, String... b) {
    if (b != null)
      for (String prefix : unnullForIteration(b)) if (startsWith(a, prefix))
        return true;
    return false;
  }

  static public boolean startsWithAny(String a, Collection<String> b, Matches m) {
    for (String prefix : unnullForIteration(b)) if (startsWith(a, prefix, m))
      return true;
    return false;
  }

  static public String mcDollar() {
    return mcName() + "$";
  }

  static public <A> List<A> ll(A... a) {
    ArrayList l = new ArrayList(a.length);
    if (a != null)
      for (A x : a) l.add(x);
    return l;
  }

  static public String afterDollar(String s) {
    return substring(s, smartIndexOf(s, '$') + 1);
  }

  static public boolean empty(Collection c) {
    return c == null || c.isEmpty();
  }

  static public boolean empty(Iterable c) {
    return c == null || !c.iterator().hasNext();
  }

  static public boolean empty(CharSequence s) {
    return s == null || s.length() == 0;
  }

  static public boolean empty(Map map) {
    return map == null || map.isEmpty();
  }

  static public boolean empty(Object[] o) {
    return o == null || o.length == 0;
  }

  static public boolean empty(BitSet bs) {
    return bs == null || bs.isEmpty();
  }

  static public boolean empty(Object o) {
    if (o instanceof Collection)
      return empty((Collection) o);
    if (o instanceof String)
      return empty((String) o);
    if (o instanceof Map)
      return empty((Map) o);
    if (o instanceof Object[])
      return empty((Object[]) o);
    if (o instanceof byte[])
      return empty((byte[]) o);
    if (o == null)
      return true;
    throw fail("unknown type for 'empty': " + getType(o));
  }

  static public boolean empty(Iterator i) {
    return i == null || !i.hasNext();
  }

  static public boolean empty(double[] a) {
    return a == null || a.length == 0;
  }

  static public boolean empty(float[] a) {
    return a == null || a.length == 0;
  }

  static public boolean empty(int[] a) {
    return a == null || a.length == 0;
  }

  static public boolean empty(long[] a) {
    return a == null || a.length == 0;
  }

  static public boolean empty(byte[] a) {
    return a == null || a.length == 0;
  }

  static public boolean empty(short[] a) {
    return a == null || a.length == 0;
  }

  static public boolean empty(MultiSet ms) {
    return ms == null || ms.isEmpty();
  }

  static public boolean empty(IMultiMap mm) {
    return mm == null || mm.size() == 0;
  }

  static public boolean empty(File f) {
    return getFileSize(f) == 0;
  }

  static public boolean empty(IntRange r) {
    return r == null || r.empty();
  }

  static public boolean empty(Rect r) {
    return !(r != null && r.w != 0 && r.h != 0);
  }

  static public boolean empty(Chain c) {
    return c == null;
  }

  static public boolean empty(AppendableChain c) {
    return c == null;
  }

  static volatile public String caseID_caseID;

  static public String caseID() {
    return caseID_caseID;
  }

  static public void caseID(String id) {
    caseID_caseID = id;
  }

  static public String quoteUnlessIdentifierOrInteger(String s) {
    return quoteIfNotIdentifierOrInteger(s);
  }

  static public String getProgramID() {
    return nempty(programID) ? formatSnippetIDOpt(programID) : "?";
  }

  static public String getProgramID(Class c) {
    String id = (String) getOpt(c, "programID");
    if (nempty(id))
      return formatSnippetID(id);
    return "?";
  }

  static public String getProgramID(Object o) {
    return getProgramID(getMainClass(o));
  }

  static public Object call_withVarargs(Object o, String methodName, Object... args) {
    try {
      if (o == null)
        return null;
      if (o instanceof Class) {
        Class c = (Class) o;
        _MethodCache cache = callOpt_getCache(c);
        Method me = cache.findStaticMethod(methodName, args);
        if (me != null)
          return invokeMethod(me, null, args);
        List<Method> methods = cache.cache.get(methodName);
        if (methods != null)
          methodSearch: for (Method m : methods) {
            {
              if (!(m.isVarArgs()))
                continue;
            }
            {
              if (!(isStaticMethod(m)))
                continue;
            }
            Object[] newArgs = massageArgsForVarArgsCall(m, args);
            if (newArgs != null)
              return invokeMethod(m, null, newArgs);
          }
        throw fail("Method " + c.getName() + "." + methodName + "(" + joinWithComma(classNames(args)) + ") not found");
      } else {
        Class c = o.getClass();
        _MethodCache cache = callOpt_getCache(c);
        Method me = cache.findMethod(methodName, args);
        if (me != null)
          return invokeMethod(me, o, args);
        List<Method> methods = cache.cache.get(methodName);
        if (methods != null)
          methodSearch: for (Method m : methods) {
            {
              if (!(m.isVarArgs()))
                continue;
            }
            Object[] newArgs = massageArgsForVarArgsCall(m, args);
            if (newArgs != null)
              return invokeMethod(m, o, newArgs);
          }
        throw fail("Method " + c.getName() + "." + methodName + "(" + joinWithComma(classNames(args)) + ") not found");
      }
    } catch (Exception __e) {
      throw rethrow(__e);
    }
  }

  static public Runnable rPcall(Runnable r) {
    return r == null ? null : () -> {
      try {
        r.run();
      } catch (Throwable __e) {
        printStackTrace(__e);
      }
    };
  }

  static public RuntimeException asRuntimeException(Throwable t) {
    if (t instanceof Error)
      _handleError((Error) t);
    return t instanceof RuntimeException ? (RuntimeException) t : new RuntimeException(t);
  }

  static public <A> WeakReference<A> newWeakReference(A a) {
    return a == null ? null : new WeakReference(a);
  }

  static public String indentedStructureForUser(Object o) {
    return indentedStructureForUser(Integer.MAX_VALUE, o);
  }

  static public String indentedStructureForUser(int levels, Object o) {
    return indentStructureString(levels, structForUser(o));
  }

  static public boolean endsWithLetterOrDigit(String s) {
    return s != null && s.length() > 0 && Character.isLetterOrDigit(s.charAt(s.length() - 1));
  }

  static volatile public boolean ping_pauseAll = false;

  static public int ping_sleep = 100;

  static volatile public boolean ping_anyActions = false;

  static public Map<Thread, Object> ping_actions = newWeakHashMap();

  static public ThreadLocal<Boolean> ping_isCleanUpThread = new ThreadLocal();

  static public boolean ping(PingSource pingSource) {
    return ping();
  }

  static public boolean ping() {
    newPing();
    if (ping_pauseAll || ping_anyActions)
      ping_impl(true);
    return true;
  }

  static public boolean ping_impl(boolean okInCleanUp) {
    try {
      if (ping_pauseAll && !isAWTThread()) {
        do Thread.sleep(ping_sleep); while (ping_pauseAll);
        return true;
      }
      if (ping_anyActions) {
        if (!okInCleanUp && !isTrue(ping_isCleanUpThread.get()))
          failIfUnlicensed();
        Object action = null;
        synchronized (ping_actions) {
          if (!ping_actions.isEmpty()) {
            action = ping_actions.get(currentThread());
            if (action instanceof Runnable)
              ping_actions.remove(currentThread());
            if (ping_actions.isEmpty())
              ping_anyActions = false;
          }
        }
        if (action instanceof Runnable)
          ((Runnable) action).run();
        else if (eq(action, "cancelled"))
          throw fail("Thread cancelled.");
      }
      return false;
    } catch (Exception __e) {
      throw rethrow(__e);
    }
  }

  static public <A> A or(A a, A b) {
    return a != null ? a : b;
  }

  static public <A> int indexOf(List<A> l, A a, int startIndex) {
    if (l == null)
      return -1;
    int n = l(l);
    for (int i = startIndex; i < n; i++) if (eq(l.get(i), a))
      return i;
    return -1;
  }

  static public <A> int indexOf(List<A> l, int startIndex, A a) {
    return indexOf(l, a, startIndex);
  }

  static public <A> int indexOf(List<A> l, A a) {
    if (l == null)
      return -1;
    return l.indexOf(a);
  }

  static public int indexOf(String a, String b) {
    return a == null || b == null ? -1 : a.indexOf(b);
  }

  static public int indexOf(String a, String b, int i) {
    return a == null || b == null ? -1 : a.indexOf(b, i);
  }

  static public int indexOf(String a, char b) {
    return a == null ? -1 : a.indexOf(b);
  }

  static public int indexOf(String a, int i, char b) {
    return indexOf(a, b, i);
  }

  static public int indexOf(String a, char b, int i) {
    return a == null ? -1 : a.indexOf(b, i);
  }

  static public int indexOf(String a, int i, String b) {
    return a == null || b == null ? -1 : a.indexOf(b, i);
  }

  static public <A> int indexOf(A[] x, A a) {
    int n = l(x);
    for (int i = 0; i < n; i++) if (eq(x[i], a))
      return i;
    return -1;
  }

  static public <A> int indexOf(Iterable<A> l, A a) {
    if (l == null)
      return -1;
    int i = 0;
    for (A x : l) {
      if (eq(x, a))
        return i;
      i++;
    }
    return -1;
  }

  static public void rotateStringBuffer(StringBuffer buf, int max) {
    try {
      if (buf == null)
        return;
      synchronized (buf) {
        if (buf.length() <= max)
          return;
        try {
          int newLength = max / 2;
          int ofs = buf.length() - newLength;
          String newString = buf.substring(ofs);
          buf.setLength(0);
          buf.append("[...] ").append(newString);
        } catch (Exception e) {
          buf.setLength(0);
        }
        buf.trimToSize();
      }
    } catch (Exception __e) {
      throw rethrow(__e);
    }
  }

  static public void rotateStringBuilder(StringBuilder buf, int max) {
    try {
      if (buf == null)
        return;
      synchronized (buf) {
        if (buf.length() <= max)
          return;
        try {
          int newLength = max / 2;
          int ofs = buf.length() - newLength;
          String newString = buf.substring(ofs);
          buf.setLength(0);
          buf.append("[...] ").append(newString);
        } catch (Exception e) {
          buf.setLength(0);
        }
        buf.trimToSize();
      }
    } catch (Exception __e) {
      throw rethrow(__e);
    }
  }

  static public Object vmBus_wrapArgs(Object... args) {
    return empty(args) ? null : l(args) == 1 ? args[0] : args;
  }

  static public void pcallFAll_minimalExceptionHandling(Collection l, Object... args) {
    if (l != null)
      for (Object f : cloneList(l)) {
        ping();
        pcallF_minimalExceptionHandling(f, args);
      }
  }

  static public void pcallFAll_minimalExceptionHandling(Iterator it, Object... args) {
    while (it.hasNext()) {
      ping();
      pcallF_minimalExceptionHandling(it.next(), args);
    }
  }

  static public Set vm_busListeners_live_cache;

  static public Set vm_busListeners_live() {
    if (vm_busListeners_live_cache == null)
      vm_busListeners_live_cache = vm_busListeners_live_load();
    return vm_busListeners_live_cache;
  }

  static public Set vm_busListeners_live_load() {
    return vm_generalIdentityHashSet("busListeners");
  }

  static public Map<String, Set> vm_busListenersByMessage_live_cache;

  static public Map<String, Set> vm_busListenersByMessage_live() {
    if (vm_busListenersByMessage_live_cache == null)
      vm_busListenersByMessage_live_cache = vm_busListenersByMessage_live_load();
    return vm_busListenersByMessage_live_cache;
  }

  static public Map<String, Set> vm_busListenersByMessage_live_load() {
    return vm_generalHashMap("busListenersByMessage");
  }

  static public PersistableThrowable persistableThrowable(Throwable e) {
    return e == null ? null : new PersistableThrowable(e);
  }

  static public String str(Object o) {
    return o == null ? "null" : o.toString();
  }

  static public String str(char[] c) {
    return new String(c);
  }

  static public String str(char[] c, int offset, int count) {
    return new String(c, offset, count);
  }

  static public boolean startsWithOneOf(String s, String... l) {
    for (String x : l) if (startsWith(s, x))
      return true;
    return false;
  }

  static public boolean startsWithOneOf(String s, Matches m, String... l) {
    for (String x : l) if (startsWith(s, x, m))
      return true;
    return false;
  }

  static public boolean isAGIBlueDomain(String domain) {
    return domainIsUnder(domain, theAGIBlueDomain());
  }

  static public String hostNameFromURL(String url) {
    try {
      return empty(url) ? null : new URL(url).getHost();
    } catch (Exception __e) {
      throw rethrow(__e);
    }
  }

  static public <A> AutoCloseable tempSetThreadLocal(final ThreadLocal<A> tl, A a) {
    if (tl == null)
      return null;
    final A prev = setThreadLocal(tl, a);
    return new AutoCloseable() {

      public String toString() {
        return "tl.set(prev);";
      }

      public void close() throws Exception {
        tl.set(prev);
      }
    };
  }

  static public boolean startsWith(String a, String b) {
    return a != null && a.startsWith(unnull(b));
  }

  static public boolean startsWith(String a, char c) {
    return nemptyString(a) && a.charAt(0) == c;
  }

  static public boolean startsWith(String a, String b, Matches m) {
    if (!startsWith(a, b))
      return false;
    if (m != null)
      m.m = new String[] { substring(a, strL(b)) };
    return true;
  }

  static public boolean startsWith(List a, List b) {
    if (a == null || listL(b) > listL(a))
      return false;
    for (int i = 0; i < listL(b); i++) if (neq(a.get(i), b.get(i)))
      return false;
    return true;
  }

  static public String substring(String s, int x) {
    return substring(s, x, strL(s));
  }

  static public String substring(String s, int x, int y) {
    if (s == null)
      return null;
    if (x < 0)
      x = 0;
    int n = s.length();
    if (y < x)
      y = x;
    if (y > n)
      y = n;
    if (x >= y)
      return "";
    return s.substring(x, y);
  }

  static public String substring(String s, IntRange r) {
    return r == null ? null : substring(s, r.start, r.end);
  }

  static public String substring(String s, CharSequence l) {
    return substring(s, lCharSequence(l));
  }

  static public String unnullForIteration(String s) {
    return s == null ? "" : s;
  }

  static public <A> Collection<A> unnullForIteration(Collection<A> l) {
    return l == null ? immutableEmptyList() : l;
  }

  static public <A> List<A> unnullForIteration(List<A> l) {
    return l == null ? immutableEmptyList() : l;
  }

  static public int[] unnullForIteration(int[] l) {
    return l == null ? emptyIntArray() : l;
  }

  static public char[] unnullForIteration(char[] l) {
    return l == null ? emptyCharArray() : l;
  }

  static public double[] unnullForIteration(double[] l) {
    return l == null ? emptyDoubleArray() : l;
  }

  static public short[] unnullForIteration(short[] l) {
    return l == null ? emptyShortArray() : l;
  }

  static public <A, B> Map<A, B> unnullForIteration(Map<A, B> l) {
    return l == null ? immutableEmptyMap() : l;
  }

  static public <A> Iterable<A> unnullForIteration(Iterable<A> i) {
    return i == null ? immutableEmptyList() : i;
  }

  static public <A> A[] unnullForIteration(A[] a) {
    return a == null ? (A[]) emptyObjectArray() : a;
  }

  static public BitSet unnullForIteration(BitSet b) {
    return b == null ? new BitSet() : b;
  }

  static public Pt unnullForIteration(Pt p) {
    return p == null ? new Pt() : p;
  }

  static public Symbol unnullForIteration(Symbol s) {
    return s == null ? emptySymbol() : s;
  }

  static public <A, B> Pair<A, B> unnullForIteration(Pair<A, B> p) {
    return p != null ? p : new Pair(null, null);
  }

  static public long unnullForIteration(Long l) {
    return l == null ? 0L : l;
  }

  static public String mcName() {
    return mc().getName();
  }

  static public int smartIndexOf(String s, String sub, int i) {
    if (s == null)
      return 0;
    i = s.indexOf(sub, min(i, l(s)));
    return i >= 0 ? i : l(s);
  }

  static public int smartIndexOf(String s, int i, char c) {
    return smartIndexOf(s, c, i);
  }

  static public int smartIndexOf(String s, char c, int i) {
    if (s == null)
      return 0;
    i = s.indexOf(c, min(i, l(s)));
    return i >= 0 ? i : l(s);
  }

  static public int smartIndexOf(String s, String sub) {
    return smartIndexOf(s, sub, 0);
  }

  static public int smartIndexOf(String s, char c) {
    return smartIndexOf(s, c, 0);
  }

  static public <A> int smartIndexOf(List<A> l, A sub) {
    return smartIndexOf(l, sub, 0);
  }

  static public <A> int smartIndexOf(List<A> l, int start, A sub) {
    return smartIndexOf(l, sub, start);
  }

  static public <A> int smartIndexOf(List<A> l, A sub, int start) {
    int i = indexOf(l, sub, start);
    return i < 0 ? l(l) : i;
  }

  static public String getType(Object o) {
    return getClassName(o);
  }

  static public long getFileSize(String path) {
    return path == null ? 0 : new File(path).length();
  }

  static public long getFileSize(File f) {
    return f == null ? 0 : f.length();
  }

  static public String quoteIfNotIdentifierOrInteger(String s) {
    if (s == null)
      return null;
    return isJavaIdentifier(s) || isInteger(s) ? s : quote(s);
  }

  static public String formatSnippetIDOpt(String s) {
    return isSnippetID(s) ? formatSnippetID(s) : s;
  }

  static public String formatSnippetID(String id) {
    return "#" + parseSnippetID(id);
  }

  static public String formatSnippetID(long id) {
    return "#" + id;
  }

  static public Class getMainClass() {
    return mc();
  }

  static public Class getMainClass(Object o) {
    try {
      if (o == null)
        return null;
      if (o instanceof Class && eq(((Class) o).getName(), "x30"))
        return (Class) o;
      ClassLoader cl = (o instanceof Class ? (Class) o : o.getClass()).getClassLoader();
      if (cl == null)
        return null;
      String name = mainClassNameForClassLoader(cl);
      return loadClassFromClassLoader_orNull(cl, name);
    } catch (Exception __e) {
      throw rethrow(__e);
    }
  }

  static final public Map<Class, _MethodCache> callOpt_cache = newDangerousWeakHashMap();

  static public Object callOpt_cached(Object o, String methodName, Object... args) {
    try {
      if (o == null)
        return null;
      if (o instanceof Class) {
        Class c = (Class) o;
        _MethodCache cache = callOpt_getCache(c);
        Method me = cache.findMethod(methodName, args);
        if (me == null || (me.getModifiers() & Modifier.STATIC) == 0)
          return null;
        return invokeMethod(me, null, args);
      } else {
        Class c = o.getClass();
        _MethodCache cache = callOpt_getCache(c);
        Method me = cache.findMethod(methodName, args);
        if (me == null)
          return null;
        return invokeMethod(me, o, args);
      }
    } catch (Exception __e) {
      throw rethrow(__e);
    }
  }

  static public _MethodCache callOpt_getCache(Class c) {
    _MethodCache cache = callOpt_cache.get(c);
    if (cache == null)
      callOpt_cache.put(c, cache = new _MethodCache(c));
    return cache;
  }

  static public Object invokeMethod(Method m, Object o, Object... args) {
    try {
      try {
        return m.invoke(o, args);
      } catch (InvocationTargetException e) {
        throw rethrow(getExceptionCause(e));
      } catch (IllegalArgumentException e) {
        throw new IllegalArgumentException(e.getMessage() + " - was calling: " + m + ", args: " + joinWithSpace(classNames(args)));
      }
    } catch (Exception __e) {
      throw rethrow(__e);
    }
  }

  static public boolean isStaticMethod(Method m) {
    return methodIsStatic(m);
  }

  static public Object[] massageArgsForVarArgsCall(Executable m, Object[] args) {
    Class<?>[] types = m.getParameterTypes();
    int n = types.length - 1, nArgs = l(args);
    if (nArgs < n)
      return null;
    for (int i = 0; i < n; i++) if (!argumentCompatibleWithType(args[i], types[i]))
      return null;
    Class varArgType = types[n].getComponentType();
    for (int i = n; i < nArgs; i++) if (!argumentCompatibleWithType(args[i], varArgType))
      return null;
    Object[] newArgs = new Object[n + 1];
    arraycopy(args, 0, newArgs, 0, n);
    int nVarArgs = nArgs - n;
    Object varArgs = Array.newInstance(varArgType, nVarArgs);
    for (int i = 0; i < nVarArgs; i++) Array.set(varArgs, i, args[n + i]);
    newArgs[n] = varArgs;
    return newArgs;
  }

  static public <A> String joinWithComma(Collection<A> c) {
    return join(", ", c);
  }

  static public String joinWithComma(Object... c) {
    return join(", ", c);
  }

  static public String joinWithComma(String... c) {
    return join(", ", c);
  }

  static public String joinWithComma(Pair p) {
    return p == null ? "" : joinWithComma(str(p.a), str(p.b));
  }

  static public List<String> classNames(Collection l) {
    return getClassNames(l);
  }

  static public List<String> classNames(Object[] l) {
    return getClassNames(asList(l));
  }

  static public void _handleError(Error e) {
  }

  static public String indentStructureString(String s) {
    return indentStructureString(100, s);
  }

  static public String indentStructureString(int levels, String s) {
    if (s == null)
      return null;
    List<String> tok = javaTokForStructure(s);
    StringBuilder buf = new StringBuilder();
    int indent = 0;
    levels = clampToInt(levels * 2L);
    for (int i = 0; i < l(tok); i++) {
      String t = tok.get(i);
      if (isOpeningBracket(t)) {
        int j = i + 5;
        if (containsClosingBracket(subList(tok, i + 2, i + 5))) {
          buf.append(joinSubList(tok, i, j));
          i = j - 1;
        } else {
          indent += 2;
          buf.append(t);
          if (indent <= levels)
            buf.append("\n").append(spaces(indent));
        }
      } else if (isClosingBracket(t)) {
        indent -= 2;
        if (indent < levels)
          buf.append("\n").append(spaces(indent));
        buf.append(t);
      } else if (indent <= levels && eq(t, ",")) {
        buf.append(t).append("\n").append(spaces(indent));
        i++;
      } else
        buf.append(t);
    }
    return str(buf);
  }

  static public String structForUser(Object o) {
    return structureForUser(o);
  }

  static public void newPing() {
    var tl = newPing_actionTL();
    Runnable action = tl == null ? null : tl.get();
    {
      if (action != null)
        action.run();
    }
  }

  static public boolean isAWTThread() {
    if (isAndroid())
      return false;
    if (isHeadless())
      return false;
    return isAWTThread_awt();
  }

  static public boolean isAWTThread_awt() {
    return SwingUtilities.isEventDispatchThread();
  }

  static public void failIfUnlicensed() {
    assertTrue("license off", licensed());
  }

  static public Thread currentThread() {
    return Thread.currentThread();
  }

  static public <A> ArrayList<A> cloneList(Iterable<A> l) {
    return l instanceof Collection ? cloneList((Collection) l) : asList(l);
  }

  static public <A> ArrayList<A> cloneList(Collection<A> l) {
    if (l == null)
      return new ArrayList();
    synchronized (collectionMutex(l)) {
      return new ArrayList<A>(l);
    }
  }

  static public Object pcallF_minimalExceptionHandling(Object f, Object... args) {
    try {
      return callFunction(f, args);
    } catch (Throwable e) {
      System.out.println(getStackTrace(e));
      _storeException(e);
    }
    return null;
  }

  static public boolean domainIsUnder(String domain, String mainDomain) {
    return eqic(domain, mainDomain) || ewic(domain, "." + mainDomain);
  }

  static public String theAGIBlueDomain() {
    return "agi.blue";
  }

  static public <A> A setThreadLocal(ThreadLocal<A> tl, A value) {
    if (tl == null)
      return null;
    A old = tl.get();
    tl.set(value);
    return old;
  }

  static public String unnull(String s) {
    return s == null ? "" : s;
  }

  static public <A> Collection<A> unnull(Collection<A> l) {
    return l == null ? emptyList() : l;
  }

  static public <A> List<A> unnull(List<A> l) {
    return l == null ? emptyList() : l;
  }

  static public int[] unnull(int[] l) {
    return l == null ? emptyIntArray() : l;
  }

  static public char[] unnull(char[] l) {
    return l == null ? emptyCharArray() : l;
  }

  static public double[] unnull(double[] l) {
    return l == null ? emptyDoubleArray() : l;
  }

  static public <A, B> Map<A, B> unnull(Map<A, B> l) {
    return l == null ? emptyMap() : l;
  }

  static public <A> Iterable<A> unnull(Iterable<A> i) {
    return i == null ? emptyList() : i;
  }

  static public <A> A[] unnull(A[] a) {
    return a == null ? (A[]) emptyObjectArray() : a;
  }

  static public BitSet unnull(BitSet b) {
    return b == null ? new BitSet() : b;
  }

  static public Pt unnull(Pt p) {
    return p == null ? new Pt() : p;
  }

  static public Symbol unnull(Symbol s) {
    return s == null ? emptySymbol() : s;
  }

  static public <A, B> Pair<A, B> unnull(Pair<A, B> p) {
    return p != null ? p : new Pair(null, null);
  }

  static public int unnull(Integer i) {
    return i == null ? 0 : i;
  }

  static public long unnull(Long l) {
    return l == null ? 0L : l;
  }

  static public double unnull(Double l) {
    return l == null ? 0.0 : l;
  }

  static public boolean nemptyString(String s) {
    return s != null && s.length() > 0;
  }

  static public int strL(String s) {
    return s == null ? 0 : s.length();
  }

  static public int listL(Collection l) {
    return l == null ? 0 : l.size();
  }

  static public boolean neq(Object a, Object b) {
    return !eq(a, b);
  }

  static public int lCharSequence(CharSequence s) {
    return s == null ? 0 : s.length();
  }

  static public <A> List<A> immutableEmptyList() {
    return Collections.emptyList();
  }

  static public int[] emptyIntArray_a = new int[0];

  static public int[] emptyIntArray() {
    return emptyIntArray_a;
  }

  static public char[] emptyCharArray = new char[0];

  static public char[] emptyCharArray() {
    return emptyCharArray;
  }

  static public double[] emptyDoubleArray = new double[0];

  static public double[] emptyDoubleArray() {
    return emptyDoubleArray;
  }

  static public short[] emptyShortArray = new short[0];

  static public short[] emptyShortArray() {
    return emptyShortArray;
  }

  static public <A, B> Map<A, B> immutableEmptyMap() {
    return Collections.emptyMap();
  }

  static public Object[] emptyObjectArray_a = new Object[0];

  static public Object[] emptyObjectArray() {
    return emptyObjectArray_a;
  }

  static public Symbol emptySymbol_value;

  static public Symbol emptySymbol() {
    if (emptySymbol_value == null)
      emptySymbol_value = symbol("");
    return emptySymbol_value;
  }

  static public int min(int a, int b) {
    return Math.min(a, b);
  }

  static public long min(long a, long b) {
    return Math.min(a, b);
  }

  static public float min(float a, float b) {
    return Math.min(a, b);
  }

  static public float min(float a, float b, float c) {
    return min(min(a, b), c);
  }

  static public double min(double a, double b) {
    return Math.min(a, b);
  }

  static public double min(double[] c) {
    double x = Double.MAX_VALUE;
    for (double d : c) x = Math.min(x, d);
    return x;
  }

  static public float min(float[] c) {
    float x = Float.MAX_VALUE;
    for (float d : c) x = Math.min(x, d);
    return x;
  }

  static public byte min(byte[] c) {
    byte x = 127;
    for (byte d : c) if (d < x)
      x = d;
    return x;
  }

  static public short min(short[] c) {
    short x = 0x7FFF;
    for (short d : c) if (d < x)
      x = d;
    return x;
  }

  static public int min(int[] c) {
    int x = Integer.MAX_VALUE;
    for (int d : c) if (d < x)
      x = d;
    return x;
  }

  static public String getClassName(Object o) {
    return o == null ? "null" : o instanceof Class ? ((Class) o).getName() : o.getClass().getName();
  }

  static public boolean isJavaIdentifier(String s) {
    if (empty(s) || !Character.isJavaIdentifierStart(s.charAt(0)))
      return false;
    for (int i = 1; i < s.length(); i++) if (!Character.isJavaIdentifierPart(s.charAt(i)))
      return false;
    return true;
  }

  static public boolean isInteger(String s) {
    int n = l(s);
    if (n == 0)
      return false;
    int i = 0;
    if (s.charAt(0) == '-')
      if (++i >= n)
        return false;
    while (i < n) {
      char c = s.charAt(i);
      if (c < '0' || c > '9')
        return false;
      ++i;
    }
    return true;
  }

  static public String quote(Object o) {
    if (o == null)
      return "null";
    return quote(str(o));
  }

  static public String quote(String s) {
    if (s == null)
      return "null";
    StringBuilder out = new StringBuilder((int) (l(s) * 1.5 + 2));
    quote_impl(s, out);
    return out.toString();
  }

  static public void quote_impl(String s, StringBuilder out) {
    out.append('"');
    int l = s.length();
    for (int i = 0; i < l; i++) {
      char c = s.charAt(i);
      if (c == '\\' || c == '"')
        out.append('\\').append(c);
      else if (c == '\r')
        out.append("\\r");
      else if (c == '\n')
        out.append("\\n");
      else if (c == '\t')
        out.append("\\t");
      else if (c == '\0')
        out.append("\\0");
      else
        out.append(c);
    }
    out.append('"');
  }

  public static boolean isSnippetID(String s) {
    try {
      parseSnippetID(s);
      return true;
    } catch (RuntimeException e) {
      return false;
    }
  }

  public static long parseSnippetID(String snippetID) {
    long id = Long.parseLong(shortenSnippetID(snippetID));
    if (id == 0)
      throw fail("0 is not a snippet ID");
    return id;
  }

  static public String mainClassNameForClassLoader(ClassLoader cl) {
    return or((String) callOpt(cl, "mainClassName"), "main");
  }

  static public Class loadClassFromClassLoader_orNull(ClassLoader cl, String name) {
    try {
      return cl == null ? null : cl.loadClass(name);
    } catch (ClassNotFoundException e) {
      return null;
    }
  }

  static public Throwable getExceptionCause(Throwable e) {
    Throwable c = e.getCause();
    return c != null ? c : e;
  }

  static public String joinWithSpace(Iterable c) {
    return join(" ", c);
  }

  static public String joinWithSpace(String... c) {
    return join(" ", c);
  }

  static public boolean methodIsStatic(Method m) {
    return (m.getModifiers() & Modifier.STATIC) != 0;
  }

  static public boolean argumentCompatibleWithType(Object arg, Class type) {
    return arg == null ? !type.isPrimitive() : isInstanceX(type, arg);
  }

  static public void arraycopy(Object[] a, Object[] b) {
    if (a != null && b != null)
      arraycopy(a, 0, b, 0, Math.min(a.length, b.length));
  }

  static public void arraycopy(Object src, int srcPos, int destPos, int n) {
    arraycopy(src, srcPos, src, destPos, n);
  }

  static public void arraycopy(Object src, int srcPos, Object dest, int destPos, int n) {
    if (n != 0)
      System.arraycopy(src, srcPos, dest, destPos, n);
  }

  public static <A> String join(String glue, Iterable<A> strings) {
    if (strings == null)
      return "";
    if (strings instanceof Collection) {
      if (((Collection) strings).size() == 1)
        return str(first((Collection) strings));
    }
    StringBuilder buf = new StringBuilder();
    Iterator<A> i = strings.iterator();
    if (i.hasNext()) {
      buf.append(i.next());
      while (i.hasNext()) buf.append(glue).append(i.next());
    }
    return buf.toString();
  }

  public static String join(String glue, String... strings) {
    return join(glue, Arrays.asList(strings));
  }

  public static String join(String glue, Object... strings) {
    return join(glue, Arrays.asList(strings));
  }

  static public <A> String join(Iterable<A> strings) {
    return join("", strings);
  }

  static public <A> String join(Iterable<A> strings, String glue) {
    return join(glue, strings);
  }

  public static String join(String[] strings) {
    return join("", strings);
  }

  static public String join(String glue, Pair p) {
    return p == null ? "" : str(p.a) + glue + str(p.b);
  }

  static public List<String> getClassNames(Collection l) {
    List<String> out = new ArrayList();
    if (l != null)
      for (Object o : l) out.add(o == null ? null : getClassName(o));
    return out;
  }

  static public <A> ArrayList<A> asList(A[] a) {
    return a == null ? new ArrayList<A>() : new ArrayList<A>(Arrays.asList(a));
  }

  static public ArrayList<Integer> asList(int[] a) {
    if (a == null)
      return null;
    ArrayList<Integer> l = emptyList(a.length);
    for (int i : a) l.add(i);
    return l;
  }

  static public ArrayList<Long> asList(long[] a) {
    if (a == null)
      return null;
    ArrayList<Long> l = emptyList(a.length);
    for (long i : a) l.add(i);
    return l;
  }

  static public ArrayList<Float> asList(float[] a) {
    if (a == null)
      return null;
    ArrayList<Float> l = emptyList(a.length);
    for (float i : a) l.add(i);
    return l;
  }

  static public ArrayList<Double> asList(double[] a) {
    if (a == null)
      return null;
    ArrayList<Double> l = emptyList(a.length);
    for (double i : a) l.add(i);
    return l;
  }

  static public ArrayList<Short> asList(short[] a) {
    if (a == null)
      return null;
    ArrayList<Short> l = emptyList(a.length);
    for (short i : a) l.add(i);
    return l;
  }

  static public <A> ArrayList<A> asList(Iterator<A> it) {
    ArrayList l = new ArrayList();
    if (it != null)
      while (it.hasNext()) l.add(it.next());
    return l;
  }

  static public <A> ArrayList<A> asList(IterableIterator<A> s) {
    return asList((Iterator) s);
  }

  static public <A> ArrayList<A> asList(Iterable<A> s) {
    if (s instanceof ArrayList)
      return (ArrayList) s;
    ArrayList l = new ArrayList();
    if (s != null)
      for (A a : s) l.add(a);
    return l;
  }

  static public <A> ArrayList<A> asList(Producer<A> p) {
    ArrayList l = new ArrayList();
    A a;
    if (p != null)
      while ((a = p.next()) != null) l.add(a);
    return l;
  }

  static public <A> ArrayList<A> asList(Enumeration<A> e) {
    ArrayList l = new ArrayList();
    if (e != null)
      while (e.hasMoreElements()) l.add(e.nextElement());
    return l;
  }

  static public <A> ArrayList<A> asList(ReverseChain<A> c) {
    return c == null ? emptyList() : c.toList();
  }

  static public <A> List<A> asList(Pair<A, A> p) {
    return p == null ? null : ll(p.a, p.b);
  }

  static public List<String> javaTokForStructure(String s) {
    return javaTok_noMLS(s);
  }

  static public int clampToInt(long l) {
    return (int) clamp(l, Integer.MIN_VALUE, Integer.MAX_VALUE);
  }

  static public boolean isOpeningBracket(String s) {
    return eqOneOf(s, "(", "{", "[");
  }

  static public boolean containsClosingBracket(List<String> l) {
    return any(__38 -> isClosingBracket(__38), l);
  }

  static public <A> List<A> subList(List<A> l, int startIndex) {
    return subList(l, startIndex, l(l));
  }

  static public <A> List<A> subList(int startIndex, List<A> l) {
    return subList(l, startIndex);
  }

  static public <A> List<A> subList(int startIndex, int endIndex, List<A> l) {
    return subList(l, startIndex, endIndex);
  }

  static public <A> List<A> subList(List<A> l, int startIndex, int endIndex) {
    if (l == null)
      return null;
    int n = l(l);
    startIndex = Math.max(0, startIndex);
    endIndex = Math.min(n, endIndex);
    if (startIndex > endIndex)
      return ll();
    if (startIndex == 0 && endIndex == n)
      return l;
    return l.subList(startIndex, endIndex);
  }

  static public <A> List<A> subList(List<A> l, IntRange r) {
    return subList(l, r.start, r.end);
  }

  static public String joinSubList(List<String> l, int i, int j) {
    return join(subList(l, i, j));
  }

  static public String joinSubList(List<String> l, int i) {
    return join(subList(l, i));
  }

  static public String joinSubList(List<String> l, IntRange r) {
    return r == null ? null : joinSubList(l, r.start, r.end);
  }

  static public String spaces(int n) {
    return rep(' ', n);
  }

  static public boolean isClosingBracket(String s) {
    return eqOneOf(s, ")", "}", "]");
  }

  static public String structureForUser(Object o) {
    structure_Data d = new structure_Data();
    d.noStringSharing = true;
    d.warnIfUnpersistable(false);
    return beautifyStructure(structure(o, d));
  }

  static public x30_pkg.x30_util.BetterThreadLocal<Runnable> newPing_actionTL;

  static public x30_pkg.x30_util.BetterThreadLocal<Runnable> newPing_actionTL() {
    if (newPing_actionTL == null)
      newPing_actionTL = vm_generalMap_getOrCreate("newPing_actionTL", () -> {
        Runnable value = (Runnable) (callF_gen(vm_generalMap_get("newPing_valueForNewThread")));
        var tl = new x30_pkg.x30_util.BetterThreadLocal<Runnable>();
        tl.set(value);
        return tl;
      });
    return newPing_actionTL;
  }

  static volatile public boolean licensed_yes = true;

  static public boolean licensed() {
    if (!licensed_yes)
      return false;
    ping_okInCleanUp();
    return true;
  }

  static public void licensed_off() {
    licensed_yes = false;
  }

  static public Object collectionMutex(List l) {
    return l;
  }

  static public Object collectionMutex(Object o) {
    if (o instanceof List)
      return o;
    String c = className(o);
    return o;
  }

  static public Object callFunction(Object f, Object... args) {
    return callF(f, args);
  }

  static public Throwable _storeException_value;

  static public void _storeException(Throwable e) {
    _storeException_value = e;
  }

  static public boolean eqic(String a, String b) {
    if ((a == null) != (b == null))
      return false;
    if (a == null)
      return true;
    return a.equalsIgnoreCase(b);
  }

  static public boolean eqic(Symbol a, Symbol b) {
    return eq(a, b);
  }

  static public boolean eqic(Symbol a, String b) {
    return eqic(asString(a), b);
  }

  static public boolean eqic(char a, char b) {
    if (a == b)
      return true;
    char u1 = Character.toUpperCase(a);
    char u2 = Character.toUpperCase(b);
    if (u1 == u2)
      return true;
    return Character.toLowerCase(u1) == Character.toLowerCase(u2);
  }

  static public boolean ewic(String a, String b) {
    return endsWithIgnoreCase(a, b);
  }

  static public boolean ewic(String a, String b, Matches m) {
    return endsWithIgnoreCase(a, b, m);
  }

  static public ArrayList emptyList() {
    return new ArrayList();
  }

  static public ArrayList emptyList(int capacity) {
    return new ArrayList(max(0, capacity));
  }

  static public ArrayList emptyList(Iterable l) {
    return l instanceof Collection ? emptyList(((Collection) l).size()) : emptyList();
  }

  static public ArrayList emptyList(Object[] l) {
    return emptyList(l(l));
  }

  static public <A> ArrayList<A> emptyList(Class<A> c) {
    return new ArrayList();
  }

  static public Map emptyMap() {
    return new HashMap();
  }

  static public WeakHasherMap<Symbol, Boolean> symbol_map = new WeakHasherMap(new Hasher<Symbol>() {

    public int hashCode(Symbol symbol) {
      return symbol.text.hashCode();
    }

    public boolean equals(Symbol a, Symbol b) {
      if (a == null)
        return b == null;
      return b != null && eq(a.text, b.text);
    }
  });

  static public Symbol symbol(String s) {
    if (s == null)
      return null;
    synchronized (symbol_map) {
      Symbol symbol = new Symbol(s, true);
      Symbol existingSymbol = symbol_map.findKey(symbol);
      if (existingSymbol == null)
        symbol_map.put(existingSymbol = symbol, true);
      return existingSymbol;
    }
  }

  static public Symbol symbol(CharSequence s) {
    if (s == null)
      return null;
    if (s instanceof Symbol)
      return (Symbol) s;
    if (s instanceof String)
      return symbol((String) s);
    return symbol(str(s));
  }

  static public Symbol symbol(Object o) {
    return symbol((CharSequence) o);
  }

  static public String shortenSnippetID(String snippetID) {
    if (snippetID.startsWith("#"))
      snippetID = snippetID.substring(1);
    String httpBlaBla = "http://tinybrain.de/";
    if (snippetID.startsWith(httpBlaBla))
      snippetID = snippetID.substring(httpBlaBla.length());
    return "" + parseLong(snippetID);
  }

  static public boolean isInstanceX(Class type, Object arg) {
    if (type == boolean.class)
      return arg instanceof Boolean;
    if (type == int.class)
      return arg instanceof Integer;
    if (type == long.class)
      return arg instanceof Long;
    if (type == float.class)
      return arg instanceof Float;
    if (type == short.class)
      return arg instanceof Short;
    if (type == char.class)
      return arg instanceof Character;
    if (type == byte.class)
      return arg instanceof Byte;
    if (type == double.class)
      return arg instanceof Double;
    return type.isInstance(arg);
  }

  static public Object first(Object list) {
    return first((Iterable) list);
  }

  static public <A> A first(List<A> list) {
    return empty(list) ? null : list.get(0);
  }

  static public <A> A first(A[] bla) {
    return bla == null || bla.length == 0 ? null : bla[0];
  }

  static public <A, B> Pair<A, B> first(Map<A, B> map) {
    return mapEntryToPair(first(entrySet(map)));
  }

  static public <A, B> Pair<A, B> first(MultiMap<A, B> mm) {
    if (mm == null)
      return null;
    var e = first(mm.data.entrySet());
    if (e == null)
      return null;
    return pair(e.getKey(), first(e.getValue()));
  }

  static public <A> A first(IterableIterator<A> i) {
    return first((Iterator<A>) i);
  }

  static public <A> A first(Iterator<A> i) {
    return i == null || !i.hasNext() ? null : i.next();
  }

  static public <A> A first(Iterable<A> i) {
    if (i == null)
      return null;
    Iterator<A> it = i.iterator();
    return it.hasNext() ? it.next() : null;
  }

  static public Character first(String s) {
    return empty(s) ? null : s.charAt(0);
  }

  static public Character first(CharSequence s) {
    return empty(s) ? null : s.charAt(0);
  }

  static public <A, B> A first(Pair<A, B> p) {
    return p == null ? null : p.a;
  }

  static public <A, B, C> A first(T3<A, B, C> t) {
    return t == null ? null : t.a;
  }

  static public Byte first(byte[] l) {
    return empty(l) ? null : l[0];
  }

  static public <A> A first(A[] l, IF1<A, Boolean> pred) {
    return firstThat(l, pred);
  }

  static public <A> A first(Iterable<A> l, IF1<A, Boolean> pred) {
    return firstThat(l, pred);
  }

  static public <A> A first(IF1<A, Boolean> pred, Iterable<A> l) {
    return firstThat(pred, l);
  }

  static public <A> A first(AppendableChain<A> a) {
    return a == null ? null : a.element;
  }

  static public List<String> javaTok_noMLS(String s) {
    ArrayList<String> tok = new ArrayList();
    int l = s == null ? 0 : s.length();
    int i = 0, n = 0;
    while (i < l) {
      int j = i;
      char c, d;
      while (j < l) {
        c = s.charAt(j);
        d = j + 1 >= l ? '\0' : s.charAt(j + 1);
        if (c == ' ' || c == '\t' || c == '\r' || c == '\n')
          ++j;
        else if (c == '/' && d == '*') {
          do ++j; while (j < l && !s.substring(j, Math.min(j + 2, l)).equals("*/"));
          j = Math.min(j + 2, l);
        } else if (c == '/' && d == '/') {
          do ++j; while (j < l && "\r\n".indexOf(s.charAt(j)) < 0);
        } else
          break;
      }
      tok.add(javaTok_substringN(s, i, j));
      ++n;
      i = j;
      if (i >= l)
        break;
      c = s.charAt(i);
      d = i + 1 >= l ? '\0' : s.charAt(i + 1);
      if (c == '\'' || c == '"') {
        char opener = c;
        ++j;
        while (j < l) {
          int c2 = s.charAt(j);
          if (c2 == opener || c2 == '\n' && opener == '\'') {
            ++j;
            break;
          } else if (c2 == '\\' && j + 1 < l)
            j += 2;
          else
            ++j;
        }
      } else if (Character.isJavaIdentifierStart(c))
        do ++j; while (j < l && Character.isJavaIdentifierPart(s.charAt(j)));
      else if (Character.isDigit(c)) {
        do ++j; while (j < l && Character.isDigit(s.charAt(j)));
        if (j < l && s.charAt(j) == 'L')
          ++j;
      } else
        ++j;
      tok.add(javaTok_substringC(s, i, j));
      ++n;
      i = j;
    }
    if ((tok.size() % 2) == 0)
      tok.add("");
    return tok;
  }

  static public float clamp(float x, float a, float b) {
    return x < a ? a : x > b ? b : x;
  }

  static public double clamp(double x, double a, double b) {
    return x < a ? a : x > b ? b : x;
  }

  static public int clamp(int x, int a, int b) {
    return x < a ? a : x > b ? b : x;
  }

  static public long clamp(long x, long a, long b) {
    return x < a ? a : x > b ? b : x;
  }

  static public boolean eqOneOf(Object o, Object... l) {
    if (l != null)
      for (Object x : l) if (eq(o, x))
        return true;
    return false;
  }

  static public <A> boolean any(Object pred, Iterable<A> l) {
    if (l != null)
      for (A a : l) if (isTrue(callF(pred, a)))
        return true;
    return false;
  }

  static public <A> boolean any(IF1<A, Boolean> pred, Iterable<A> l) {
    if (l != null)
      for (A a : l) if (pred.get(a))
        return true;
    return false;
  }

  static public <A> boolean any(Iterable<A> l, IF1<A, Boolean> pred) {
    return any(pred, l);
  }

  static public <A> boolean any(A[] l, IF1<A, Boolean> pred) {
    if (l != null)
      for (A a : l) if (pred.get(a))
        return true;
    return false;
  }

  static public boolean any(Iterable<Boolean> l) {
    if (l != null)
      for (Boolean a : l) if (isTrue(a))
        return true;
    return false;
  }

  static public String rep(int n, char c) {
    return repeat(c, n);
  }

  static public String rep(char c, int n) {
    return repeat(c, n);
  }

  static public <A> List<A> rep(A a, int n) {
    return repeat(a, n);
  }

  static public <A> List<A> rep(int n, A a) {
    return repeat(n, a);
  }

  static public String beautifyStructure(String s) {
    List<String> tok = javaTokForStructure(s);
    structure_addTokenMarkers(tok);
    jreplace(tok, "lhm", "");
    return join(tok);
  }

  static public <A> A vm_generalMap_getOrCreate(Object key, F0<A> create) {
    return vm_generalMap_getOrCreate(key, f0ToIF0(create));
  }

  static public <A> A vm_generalMap_getOrCreate(Object key, IF0<A> create) {
    Map generalMap = vm_generalMap();
    if (generalMap == null)
      return null;
    synchronized (generalMap) {
      A a = (A) (vm_generalMap_get(key));
      if (a == null)
        vm_generalMap_put(key, a = create == null ? null : create.get());
      return a;
    }
  }

  static public <A> A callF_gen(F0<A> f) {
    return f == null ? null : f.get();
  }

  static public <A, B> B callF_gen(F1<A, B> f, A a) {
    return f == null ? null : f.get(a);
  }

  static public <A> A callF_gen(IF0<A> f) {
    return f == null ? null : f.get();
  }

  static public <A, B> B callF_gen(IF1<A, B> f, A a) {
    return f == null ? null : f.get(a);
  }

  static public <A, B> B callF_gen(A a, IF1<A, B> f) {
    return f == null ? null : f.get(a);
  }

  static public <A, B, C> C callF_gen(IF2<A, B, C> f, A a, B b) {
    return f == null ? null : f.get(a, b);
  }

  static public <A> void callF_gen(VF1<A> f, A a) {
    {
      if (f != null)
        f.get(a);
    }
  }

  static public <A> void callF_gen(A a, IVF1<A> f) {
    {
      if (f != null)
        f.get(a);
    }
  }

  static public <A> void callF_gen(IVF1<A> f, A a) {
    {
      if (f != null)
        f.get(a);
    }
  }

  static public Object callF_gen(Runnable r) {
    {
      if (r != null)
        r.run();
    }
    return null;
  }

  static public Object callF_gen(Object f, Object... args) {
    return callF(f, args);
  }

  static public Object vm_generalMap_get(Object key) {
    return vm_generalMap().get(key);
  }

  static public String className(Object o) {
    return getClassName(o);
  }

  static public String asString(Object o) {
    return o == null ? null : o.toString();
  }

  static public boolean endsWithIgnoreCase(String a, String b) {
    int la = l(a), lb = l(b);
    return la >= lb && regionMatchesIC(a, la - lb, b, 0, lb);
  }

  static public boolean endsWithIgnoreCase(String a, String b, Matches m) {
    if (!endsWithIgnoreCase(a, b))
      return false;
    if (m != null)
      m.m = new String[] { substring(a, 0, l(a) - l(b)) };
    return true;
  }

  static public int max(int a, int b) {
    return Math.max(a, b);
  }

  static public int max(int a, int b, int c) {
    return max(max(a, b), c);
  }

  static public long max(int a, long b) {
    return Math.max((long) a, b);
  }

  static public long max(long a, long b) {
    return Math.max(a, b);
  }

  static public double max(int a, double b) {
    return Math.max((double) a, b);
  }

  static public float max(float a, float b) {
    return Math.max(a, b);
  }

  static public double max(double a, double b) {
    return Math.max(a, b);
  }

  static public int max(Collection<Integer> c) {
    int x = Integer.MIN_VALUE;
    for (int i : c) x = max(x, i);
    return x;
  }

  static public double max(double[] c) {
    if (c.length == 0)
      return Double.MIN_VALUE;
    double x = c[0];
    for (int i = 1; i < c.length; i++) x = Math.max(x, c[i]);
    return x;
  }

  static public float max(float[] c) {
    if (c.length == 0)
      return Float.MAX_VALUE;
    float x = c[0];
    for (int i = 1; i < c.length; i++) x = Math.max(x, c[i]);
    return x;
  }

  static public byte max(byte[] c) {
    byte x = -128;
    for (byte d : c) if (d > x)
      x = d;
    return x;
  }

  static public short max(short[] c) {
    short x = -0x8000;
    for (short d : c) if (d > x)
      x = d;
    return x;
  }

  static public int max(int[] c) {
    int x = Integer.MIN_VALUE;
    for (int d : c) if (d > x)
      x = d;
    return x;
  }

  static public <A extends Comparable<A>> A max(A a, A b) {
    return cmp(a, b) >= 0 ? a : b;
  }

  static public long parseLong(String s) {
    if (empty(s))
      return 0;
    return Long.parseLong(dropSuffix("L", s));
  }

  static public long parseLong(Object s) {
    return Long.parseLong((String) s);
  }

  static public <A, B> Pair<A, B> mapEntryToPair(Map.Entry<A, B> e) {
    return e == null ? null : pair(e.getKey(), e.getValue());
  }

  static public <A, B> Set<Map.Entry<A, B>> entrySet(Map<A, B> map) {
    return _entrySet(map);
  }

  static public <A, B> Pair<A, B> pair(A a, B b) {
    return new Pair(a, b);
  }

  static public <A> Pair<A, A> pair(A a) {
    return new Pair(a, a);
  }

  static public <A> A firstThat(Iterable<A> l, IF1<A, Boolean> pred) {
    for (A a : unnullForIteration(l)) if (pred.get(a))
      return a;
    return null;
  }

  static public <A> A firstThat(A[] l, IF1<A, Boolean> pred) {
    for (A a : unnullForIteration(l)) if (pred.get(a))
      return a;
    return null;
  }

  static public <A> A firstThat(IF1<A, Boolean> pred, Iterable<A> l) {
    return firstThat(l, pred);
  }

  static public <A> A firstThat(IF1<A, Boolean> pred, A[] l) {
    return firstThat(l, pred);
  }

  static public String javaTok_substringN(String s, int i, int j) {
    if (i == j)
      return "";
    if (j == i + 1 && s.charAt(i) == ' ')
      return " ";
    return s.substring(i, j);
  }

  static public String javaTok_substringC(String s, int i, int j) {
    return s.substring(i, j);
  }

  static public String repeat(char c, int n) {
    n = Math.max(n, 0);
    char[] chars = new char[n];
    for (int i = 0; i < n; i++) chars[i] = c;
    return new String(chars);
  }

  static public <A> List<A> repeat(A a, int n) {
    n = Math.max(n, 0);
    List<A> l = new ArrayList(n);
    for (int i = 0; i < n; i++) l.add(a);
    return l;
  }

  static public <A> List<A> repeat(int n, A a) {
    return repeat(a, n);
  }

  static public String structure_addTokenMarkers(String s) {
    return join(structure_addTokenMarkers(javaTokForStructure(s)));
  }

  static public List<String> structure_addTokenMarkers(List<String> tok) {
    TreeSet<Integer> refs = new TreeSet();
    for (int i = 1; i < l(tok); i += 2) {
      String t = tok.get(i);
      if (t.startsWith("t") && isInteger(t.substring(1)))
        refs.add(parseInt(t.substring(1)));
    }
    if (empty(refs))
      return tok;
    for (int i : refs) {
      int idx = i * 2 + 1;
      if (idx >= l(tok))
        continue;
      String t = "";
      if (endsWithLetterOrDigit(tok.get(idx - 1)))
        t = " ";
      tok.set(idx, t + "m" + i + " " + tok.get(idx));
    }
    return tok;
  }

  static public String jreplace(String s, String in, String out) {
    return jreplace(s, in, out, null);
  }

  static public String jreplace(String s, String in, String out, Object condition) {
    List<String> tok = javaTok(s);
    return jreplace(tok, in, out, condition) ? join(tok) : s;
  }

  static public boolean jreplace(List<String> tok, String in, String out) {
    return jreplace(tok, in, out, false, true, null);
  }

  static public boolean jreplace(List<String> tok, String in, String out, Object condition) {
    return jreplace(tok, in, out, false, true, condition);
  }

  static public boolean jreplace(List<String> tok, String in, String out, IF2<List<String>, Integer, Boolean> condition) {
    return jreplace(tok, in, out, (Object) condition);
  }

  static public boolean jreplace(List<String> tok, String in, String out, boolean ignoreCase, boolean reTok, Object condition) {
    String[] toks = javaTokForJFind_array(in);
    int lTokin = toks.length * 2 + 1;
    boolean anyChange = false;
    int i = -1;
    for (int n = 0; n < 10000; n++) {
      i = findCodeTokens(tok, i + 1, ignoreCase, toks, condition);
      if (i < 0)
        return anyChange;
      List<String> subList = tok.subList(i - 1, i + lTokin - 1);
      String expansion = jreplaceExpandRefs(out, subList);
      int end = i + lTokin - 2;
      clearAllTokens(tok, i, end);
      tok.set(i, expansion);
      if (reTok)
        reTok(tok, i, end);
      i = end;
      anyChange = true;
    }
    throw fail("woot? 10000! " + quote(in) + " => " + quote(out));
  }

  static public boolean jreplace_debug = false;

  static public <A> IF0<A> f0ToIF0(F0<A> f) {
    return f == null ? null : () -> f.get();
  }

  static public Map vm_generalMap_map;

  static public Map vm_generalMap() {
    if (vm_generalMap_map == null)
      vm_generalMap_map = (Map) get(javax(), "generalMap");
    return vm_generalMap_map;
  }

  static public Object vm_generalMap_put(Object key, Object value) {
    return mapPutOrRemove(vm_generalMap(), key, value);
  }

  static public boolean regionMatchesIC(String a, int offsetA, String b, int offsetB, int len) {
    return a != null && a.regionMatches(true, offsetA, b, offsetB, len);
  }

  static public int cmp(Number a, Number b) {
    return a == null ? b == null ? 0 : -1 : cmp(a.doubleValue(), b.doubleValue());
  }

  static public int cmp(double a, double b) {
    return a < b ? -1 : a == b ? 0 : 1;
  }

  static public int cmp(int a, int b) {
    return a < b ? -1 : a == b ? 0 : 1;
  }

  static public int cmp(long a, long b) {
    return a < b ? -1 : a == b ? 0 : 1;
  }

  static public int cmp(Object a, Object b) {
    if (a == null)
      return b == null ? 0 : -1;
    if (b == null)
      return 1;
    return ((Comparable) a).compareTo(b);
  }

  static public String dropSuffix(String suffix, String s) {
    return nempty(suffix) && endsWith(s, suffix) ? s.substring(0, l(s) - l(suffix)) : s;
  }

  static public <A, B> Set<Map.Entry<A, B>> _entrySet(Map<A, B> map) {
    return map == null ? Collections.EMPTY_SET : map.entrySet();
  }

  static public int parseInt(String s) {
    return emptyString(s) ? 0 : Integer.parseInt(s);
  }

  static public int parseInt(char c) {
    return Integer.parseInt(str(c));
  }

  static public int javaTok_n, javaTok_elements;

  static public boolean javaTok_opt = false;

  static public List<String> javaTok(String s) {
    ++javaTok_n;
    ArrayList<String> tok = new ArrayList();
    int l = s == null ? 0 : s.length();
    int i = 0;
    while (i < l) {
      int j = i;
      char c, d;
      while (j < l) {
        c = s.charAt(j);
        d = j + 1 >= l ? '\0' : s.charAt(j + 1);
        if (c == ' ' || c == '\t' || c == '\r' || c == '\n')
          ++j;
        else if (c == '/' && d == '*') {
          do ++j; while (j < l && !regionMatches(s, j, "*/"));
          j = Math.min(j + 2, l);
        } else if (c == '/' && d == '/') {
          do ++j; while (j < l && "\r\n".indexOf(s.charAt(j)) < 0);
        } else
          break;
      }
      tok.add(javaTok_substringN(s, i, j));
      i = j;
      if (i >= l)
        break;
      c = s.charAt(i);
      d = i + 1 >= l ? '\0' : s.charAt(i + 1);
      if (c == '\'' && Character.isJavaIdentifierStart(d) && i + 2 < l && "'\\".indexOf(s.charAt(i + 2)) < 0) {
        j += 2;
        while (j < l && Character.isJavaIdentifierPart(s.charAt(j))) ++j;
      } else if (c == '\'' || c == '"') {
        char opener = c;
        ++j;
        while (j < l) {
          int c2 = s.charAt(j);
          if (c2 == opener || c2 == '\n' && opener == '\'') {
            ++j;
            break;
          } else if (c2 == '\\' && j + 1 < l)
            j += 2;
          else
            ++j;
        }
      } else if (Character.isJavaIdentifierStart(c))
        do ++j; while (j < l && (Character.isJavaIdentifierPart(s.charAt(j)) || s.charAt(j) == '\''));
      else if (Character.isDigit(c)) {
        do ++j; while (j < l && Character.isDigit(s.charAt(j)));
        if (j < l && s.charAt(j) == 'L')
          ++j;
      } else if (c == '[' && d == '[') {
        do ++j; while (j < l && !regionMatches(s, j, "]]"));
        j = Math.min(j + 2, l);
      } else if (c == '[' && d == '=' && i + 2 < l && s.charAt(i + 2) == '[') {
        do ++j; while (j + 2 < l && !regionMatches(s, j, "]=]"));
        j = Math.min(j + 3, l);
      } else
        ++j;
      tok.add(javaTok_substringC(s, i, j));
      i = j;
    }
    if ((tok.size() % 2) == 0)
      tok.add("");
    javaTok_elements += tok.size();
    return tok;
  }

  static public List<String> javaTok(List<String> tok) {
    return javaTokWithExisting(join(tok), tok);
  }

  static public Map<String, String[]> javaTokForJFind_array_cache = synchronizedMRUCache(1000);

  static public String[] javaTokForJFind_array(String s) {
    String[] tok = javaTokForJFind_array_cache.get(s);
    if (tok == null)
      javaTokForJFind_array_cache.put(s, tok = codeTokensAsStringArray(jfind_preprocess(javaTok(s))));
    return tok;
  }

  static public int findCodeTokens(List<String> tok, String... tokens) {
    return findCodeTokens(tok, 1, false, tokens);
  }

  static public int findCodeTokens(List<String> tok, boolean ignoreCase, String... tokens) {
    return findCodeTokens(tok, 1, ignoreCase, tokens);
  }

  static public int findCodeTokens(List<String> tok, int startIdx, boolean ignoreCase, String... tokens) {
    return findCodeTokens(tok, startIdx, ignoreCase, tokens, null);
  }

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

  static public int findCodeTokens_bails, findCodeTokens_nonbails;

  static public interface findCodeTokens_Matcher {

    public boolean get(String token);
  }

  static public 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;
    if (i >= end)
      return -1;
    String firstToken = tokens[0];
    if (!ignoreCase && !findCodeTokens_specials.contains(firstToken)) {
      while (i < end && !firstToken.equals(tok.get(i))) i += 2;
    }
    findCodeTokens_Matcher[] matchers = new findCodeTokens_Matcher[nTokens];
    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);
      matchers[j] = matcher;
    }
    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))
        return i;
    }
    return -1;
  }

  static public String jreplaceExpandRefs(String s, List<String> tokref) {
    if (!contains(s, '$'))
      return s;
    List<String> tok = javaTok(s);
    for (int i = 1; i < l(tok); i += 2) {
      String t = tok.get(i);
      if (t.startsWith("$") && isInteger(t.substring(1))) {
        String x = tokref.get(-1 + parseInt(t.substring(1)) * 2);
        tok.set(i, x);
      } else if (t.equals("\\")) {
        tok.set(i, "");
        i += 2;
      }
    }
    return join(tok);
  }

  static public void clearAllTokens(List<String> tok) {
    for (int i = 0; i < tok.size(); i++) tok.set(i, "");
  }

  static public void clearAllTokens(List<String> tok, int i, int j) {
    for (; i < j; i++) tok.set(i, "");
  }

  static public List<String> reTok(List<String> tok) {
    replaceCollection(tok, javaTok(tok));
    return tok;
  }

  static public List<String> reTok(List<String> tok, int i) {
    return reTok(tok, i, i + 1);
  }

  static public List<String> reTok(List<String> tok, int i, int j) {
    i = max(i & ~1, 0);
    j = min(l(tok), j | 1);
    if (i >= j)
      return tok;
    List<String> t = javaTok(joinSubList(tok, i, j));
    replaceListPart(tok, i, j, t);
    return tok;
  }

  static public List<String> reTok(List<String> tok, IntRange r) {
    if (r != null)
      reTok(tok, r.start, r.end);
    return tok;
  }

  static public <A, B> B mapPutOrRemove(Map<A, B> map, A key, B value) {
    if (map != null && key != null)
      if (value != null)
        return map.put(key, value);
      else
        return map.remove(key);
    return null;
  }

  static public boolean endsWith(String a, String b) {
    return a != null && a.endsWith(b);
  }

  static public boolean endsWith(String a, char c) {
    return nempty(a) && lastChar(a) == c;
  }

  static public boolean endsWith(String a, String b, Matches m) {
    if (!endsWith(a, b))
      return false;
    m.m = new String[] { dropLast(l(b), a) };
    return true;
  }

  static public boolean emptyString(String s) {
    return s == null || s.length() == 0;
  }

  static public boolean regionMatches(String a, int offsetA, String b, int offsetB, int len) {
    return a != null && b != null && a.regionMatches(offsetA, b, offsetB, len);
  }

  static public boolean regionMatches(String a, int offsetA, String b) {
    return regionMatches(a, offsetA, b, 0, l(b));
  }

  static public List<String> javaTokWithExisting(String s, List<String> existing) {
    ++javaTok_n;
    int nExisting = javaTok_opt && existing != null ? existing.size() : 0;
    ArrayList<String> tok = existing != null ? new ArrayList(nExisting) : new ArrayList();
    int l = s.length();
    int i = 0, n = 0;
    while (i < l) {
      int j = i;
      char c, d;
      while (j < l) {
        c = s.charAt(j);
        d = j + 1 >= l ? '\0' : s.charAt(j + 1);
        if (c == ' ' || c == '\t' || c == '\r' || c == '\n')
          ++j;
        else if (c == '/' && d == '*') {
          do ++j; while (j < l && !s.substring(j, Math.min(j + 2, l)).equals("*/"));
          j = Math.min(j + 2, l);
        } else if (c == '/' && d == '/') {
          do ++j; while (j < l && "\r\n".indexOf(s.charAt(j)) < 0);
        } else
          break;
      }
      if (n < nExisting && javaTokWithExisting_isCopyable(existing.get(n), s, i, j))
        tok.add(existing.get(n));
      else
        tok.add(javaTok_substringN(s, i, j));
      ++n;
      i = j;
      if (i >= l)
        break;
      c = s.charAt(i);
      d = i + 1 >= l ? '\0' : s.charAt(i + 1);
      if (c == '\'' && Character.isJavaIdentifierStart(d) && i + 2 < l && "'\\".indexOf(s.charAt(i + 2)) < 0) {
        j += 2;
        while (j < l && Character.isJavaIdentifierPart(s.charAt(j))) ++j;
      } else if (c == '\'' || c == '"') {
        char opener = c;
        ++j;
        while (j < l) {
          if (s.charAt(j) == opener) {
            ++j;
            break;
          } else if (s.charAt(j) == '\\' && j + 1 < l)
            j += 2;
          else
            ++j;
        }
      } else if (Character.isJavaIdentifierStart(c))
        do ++j; while (j < l && (Character.isJavaIdentifierPart(s.charAt(j)) || "'".indexOf(s.charAt(j)) >= 0));
      else if (Character.isDigit(c)) {
        do ++j; while (j < l && Character.isDigit(s.charAt(j)));
        if (j < l && s.charAt(j) == 'L')
          ++j;
      } else if (c == '[' && d == '[') {
        do ++j; while (j + 1 < l && !s.substring(j, j + 2).equals("]]"));
        j = Math.min(j + 2, l);
      } else if (c == '[' && d == '=' && i + 2 < l && s.charAt(i + 2) == '[') {
        do ++j; while (j + 2 < l && !s.substring(j, j + 3).equals("]=]"));
        j = Math.min(j + 3, l);
      } else
        ++j;
      if (n < nExisting && javaTokWithExisting_isCopyable(existing.get(n), s, i, j))
        tok.add(existing.get(n));
      else
        tok.add(javaTok_substringC(s, i, j));
      ++n;
      i = j;
    }
    if ((tok.size() % 2) == 0)
      tok.add("");
    javaTok_elements += tok.size();
    return tok;
  }

  static public boolean javaTokWithExisting_isCopyable(String t, String s, int i, int j) {
    return t.length() == j - i && s.regionMatches(i, t, 0, j - i);
  }

  static public <A, B> Map<A, B> synchronizedMRUCache(int maxSize) {
    return synchroMap(new MRUCache(maxSize));
  }

  static public String[] codeTokensAsStringArray(List<String> tok) {
    int n = max(0, (l(tok) - 1) / 2);
    String[] out = new String[n];
    for (int i = 0; i < n; i++) out[i] = tok.get(i * 2 + 1);
    return out;
  }

  static public int jfind(String s, String in) {
    return jfind(javaTok(s), in);
  }

  static public int jfind(List<String> tok, String in) {
    return jfind(tok, 1, in);
  }

  static public int jfind(List<String> tok, int startIdx, String in) {
    return jfind(tok, startIdx, in, (ITokCondition) null);
  }

  static public int jfind(List<String> tok, String in, Object condition) {
    return jfind(tok, 1, in, condition);
  }

  static public int jfind(List<String> tok, String in, IIntPred condition) {
    return jfind(tok, 1, in, condition);
  }

  static public int jfind(List<String> tok, int startIndex, String in, IIntPred condition) {
    return jfind(tok, startIndex, in, tokCondition(condition));
  }

  static public int jfind(List<String> tok, String in, ITokCondition condition) {
    return jfind(tok, 1, in, condition);
  }

  static public int jfind(List<String> tok, int startIndex, String in, ITokCondition condition) {
    return jfind(tok, startIndex, in, (Object) condition);
  }

  static public int jfind(List<String> tok, int startIdx, String in, Object condition) {
    return jfind(tok, startIdx, javaTokForJFind_array(in), condition);
  }

  static public int jfind(List<String> tok, List<String> tokin) {
    return jfind(tok, 1, tokin);
  }

  static public int jfind(List<String> tok, int startIdx, List<String> tokin) {
    return jfind(tok, startIdx, tokin, null);
  }

  static public int jfind(List<String> tok, int startIdx, String[] tokinC, Object condition) {
    return findCodeTokens(tok, startIdx, false, tokinC, condition);
  }

  static public int jfind(List<String> tok, int startIdx, List<String> tokin, Object condition) {
    return jfind(tok, startIdx, codeTokensAsStringArray(tokin), condition);
  }

  static public List<String> jfind_preprocess(List<String> tok) {
    for (String type : litlist("quoted", "id", "int")) replaceSublist(tok, ll("<", "", type, "", ">"), ll("<" + type + ">"));
    replaceSublist(tok, ll("\\", "", "*"), ll("\\*"));
    return tok;
  }

  static public <A> HashSet<A> lithashset(A... items) {
    HashSet<A> set = new HashSet();
    for (A a : items) set.add(a);
    return set;
  }

  static public boolean isQuoted(String s) {
    if (isNormalQuoted(s))
      return true;
    return isMultilineQuoted(s);
  }

  static public boolean isIdentifier(String s) {
    return isJavaIdentifier(s);
  }

  static public boolean checkTokCondition(Object condition, List<String> tok, int i) {
    if (condition instanceof TokCondition)
      return ((TokCondition) condition).get(tok, i);
    return checkCondition(condition, tok, i);
  }

  static public boolean contains(Collection c, Object o) {
    return c != null && c.contains(o);
  }

  static public boolean contains(Iterable it, Object a) {
    if (it != null)
      for (Object o : it) if (eq(a, o))
        return true;
    return false;
  }

  static public boolean contains(Object[] x, Object o) {
    if (x != null)
      for (Object a : x) if (eq(a, o))
        return true;
    return false;
  }

  static public boolean contains(String s, char c) {
    return s != null && s.indexOf(c) >= 0;
  }

  static public boolean contains(String s, String b) {
    return s != null && s.indexOf(b) >= 0;
  }

  static public boolean contains(BitSet bs, int i) {
    return bs != null && bs.get(i);
  }

  static public <A> boolean contains(Producer<A> p, A a) {
    if (p != null && a != null)
      while (true) {
        A x = p.next();
        if (x == null)
          break;
        if (eq(x, a))
          return true;
      }
    return false;
  }

  static public boolean contains(Rect r, Pt p) {
    return rectContains(r, p);
  }

  static public <A> void replaceCollection(Collection<A> dest, Collection<A> src) {
    if (dest == src)
      return;
    dest.clear();
    if (src != null)
      dest.addAll(src);
  }

  static public void replaceListPart(List l, int i, int j, List l2) {
    replaceSublist(l, i, j, l2);
  }

  static public char lastChar(String s) {
    return empty(s) ? '\0' : s.charAt(l(s) - 1);
  }

  static public <A> A[] dropLast(A[] a) {
    return dropLast(a, 1);
  }

  static public <A> A[] dropLast(A[] a, int n) {
    if (a == null)
      return null;
    n = Math.min(n, a.length);
    A[] b = arrayOfSameType(a, a.length - n);
    System.arraycopy(a, 0, b, 0, b.length);
    return b;
  }

  static public <A> List<A> dropLast(List<A> l) {
    return subList(l, 0, l(l) - 1);
  }

  static public <A> List<A> dropLast(int n, List<A> l) {
    return subList(l, 0, l(l) - n);
  }

  static public <A> List<A> dropLast(Iterable<A> l) {
    return dropLast(asList(l));
  }

  static public String dropLast(String s) {
    return substring(s, 0, l(s) - 1);
  }

  static public String dropLast(String s, int n) {
    return substring(s, 0, l(s) - n);
  }

  static public String dropLast(int n, String s) {
    return dropLast(s, n);
  }

  static public Map synchroMap() {
    return synchroHashMap();
  }

  static public <A, B> Map<A, B> synchroMap(Map<A, B> map) {
    return Collections.synchronizedMap(map);
  }

  static public ITokCondition tokCondition(IIntPred condition) {
    return condition == null ? null : (tok, nIdx) -> condition.get(nIdx);
  }

  static public <A> ArrayList<A> litlist(A... a) {
    ArrayList l = new ArrayList(a.length);
    for (A x : a) l.add(x);
    return l;
  }

  static public <A> List<A> replaceSublist(List<A> l, List<A> x, List<A> y) {
    if (x == null)
      return l;
    int i = 0;
    while (true) {
      i = indexOfSubList(l, x, i);
      if (i < 0)
        break;
      replaceSublist(l, i, i + l(x), y);
      i += l(y);
    }
    return l;
  }

  static public <A> List<A> replaceSublist(List<A> l, int fromIndex, int toIndex, List<A> y) {
    int n = y.size(), toIndex_new = fromIndex + n;
    if (toIndex_new < toIndex) {
      removeSubList(l, toIndex_new, toIndex);
      copyListPart(y, 0, l, fromIndex, n);
    } else {
      copyListPart(y, 0, l, fromIndex, toIndex - fromIndex);
      if (toIndex_new > toIndex)
        l.addAll(toIndex, subList(y, toIndex - fromIndex));
    }
    return l;
  }

  static public <A> List<A> replaceSublist(List<A> l, IntRange r, List<A> y) {
    return replaceSublist(l, r.start, r.end, y);
  }

  static public boolean isNormalQuoted(String s) {
    int l = l(s);
    if (!(l >= 2 && s.charAt(0) == '"' && lastChar(s) == '"'))
      return false;
    int j = 1;
    while (j < l) if (s.charAt(j) == '"')
      return j == l - 1;
    else if (s.charAt(j) == '\\' && j + 1 < l)
      j += 2;
    else
      ++j;
    return false;
  }

  static public boolean isMultilineQuoted(String s) {
    if (!startsWith(s, "["))
      return false;
    int i = 1;
    while (i < s.length() && s.charAt(i) == '=') ++i;
    return i < s.length() && s.charAt(i) == '[';
  }

  static public boolean checkCondition(Object condition, Object... args) {
    return isTrue(callF(condition, args));
  }

  static public <A> boolean checkCondition(IF1<A, Boolean> condition, A arg) {
    return isTrue(callF(condition, arg));
  }

  static public boolean rectContains(int x1, int y1, int w, int h, Pt p) {
    return p.x >= x1 && p.y >= y1 && p.x < x1 + w && p.y < y1 + h;
  }

  static public boolean rectContains(Rect a, Rect b) {
    return b.x >= a.x && b.y >= a.y && b.x2() <= a.x2() && b.y2() <= a.y2();
  }

  static public boolean rectContains(Rect a, Rectangle b) {
    return rectContains(a, toRect(b));
  }

  static public boolean rectContains(Rect a, int x, int y) {
    return a != null && a.contains(x, y);
  }

  static public boolean rectContains(Rect a, Pt p) {
    return a != null && p != null && a.contains(p);
  }

  static public <A> A[] arrayOfSameType(A[] a, int n) {
    return newObjectArrayOfSameType(a, n);
  }

  static public Map synchroHashMap() {
    return synchronizedMap(new HashMap());
  }

  static public <A> int indexOfSubList(List<A> x, List<A> y) {
    return indexOfSubList(x, y, 0);
  }

  static public <A> int indexOfSubList(List<A> x, List<A> y, int i) {
    outer: for (; i + l(y) <= l(x); i++) {
      for (int j = 0; j < l(y); j++) if (neq(x.get(i + j), y.get(j)))
        continue outer;
      return i;
    }
    return -1;
  }

  static public <A> int indexOfSubList(List<A> x, A[] y, int i) {
    outer: for (; i + l(y) <= l(x); i++) {
      for (int j = 0; j < l(y); j++) if (neq(x.get(i + j), y[j]))
        continue outer;
      return i;
    }
    return -1;
  }

  static public void removeSubList(List l, int from, int to) {
    if (l != null)
      subList(l, from, to).clear();
  }

  static public void removeSubList(List l, int from) {
    if (l != null)
      subList(l, from).clear();
  }

  static public <A, B extends A> void copyListPart(List<B> a, int i1, List<A> b, int i2, int n) {
    if (a == null || b == null)
      return;
    for (int i = 0; i < n; i++) b.set(i2 + i, a.get(i1 + i));
  }

  static public Rect toRect(Rectangle r) {
    return r == null ? null : new Rect(r);
  }

  static public Rect toRect(RectangularShape r) {
    return r == null ? null : toRect(r.getBounds());
  }

  static public Rect toRect(DoubleRect r) {
    if (r == null)
      return null;
    int x = iround(r.x), y = iround(r.y);
    return new Rect(x, y, iround(r.x2()) - x, iround(r.y2()) - y);
  }

  static public Rect toRect(Rect r) {
    return r;
  }

  static public <A> A[] newObjectArrayOfSameType(A[] a) {
    return newObjectArrayOfSameType(a, a.length);
  }

  static public <A> A[] newObjectArrayOfSameType(A[] a, int n) {
    return (A[]) Array.newInstance(a.getClass().getComponentType(), n);
  }

  static public Map synchronizedMap() {
    return synchroMap();
  }

  static public <A, B> Map<A, B> synchronizedMap(Map<A, B> map) {
    return synchroMap(map);
  }

  static public int iround(double d) {
    return (int) Math.round(d);
  }

  static public int iround(Number n) {
    return iround(toDouble(n));
  }

  static public double toDouble(Object o) {
    if (o instanceof Number)
      return ((Number) o).doubleValue();
    if (o instanceof BigInteger)
      return ((BigInteger) o).doubleValue();
    if (o instanceof String)
      return parseDouble((String) o);
    if (o == null)
      return 0.0;
    throw fail(o);
  }

  static public double parseDouble(String s) {
    return empty(s) ? 0.0 : Double.parseDouble(s);
  }

  final static public class _MethodCache {

    final public Class c;

    final public HashMap<String, List<Method>> cache = new HashMap();

    public _MethodCache(Class c) {
      this.c = c;
      _init();
    }

    public void _init() {
      Class _c = c;
      java.lang.Module myModule = getClass().getModule();
      boolean anyHiddenClasses = false;
      while (_c != null) {
        boolean exported = classIsExportedTo(_c, myModule);
        if (!exported)
          anyHiddenClasses = true;
        else
          for (Method m : _c.getDeclaredMethods()) if ((anyHiddenClasses || !isAbstract(m)) && !reflection_isForbiddenMethod(m))
            multiMapPut(cache, m.getName(), makeAccessible(m));
        _c = _c.getSuperclass();
      }
      for (Class intf : allInterfacesImplementedBy(c)) for (Method m : intf.getDeclaredMethods()) if ((anyHiddenClasses || m.isDefault()) && !reflection_isForbiddenMethod(m))
        multiMapPut(cache, m.getName(), makeAccessible(m));
    }

    public Method findMethod(String method, Object[] args) {
      try {
        List<Method> m = cache.get(method);
        if (m == null)
          return null;
        int n = m.size();
        for (int i = 0; i < n; i++) {
          Method me = m.get(i);
          if (call_checkArgs(me, args, false))
            return me;
        }
        return null;
      } catch (Exception __e) {
        throw rethrow(__e);
      }
    }

    public Method findStaticMethod(String method, Object[] args) {
      try {
        List<Method> m = cache.get(method);
        if (m == null)
          return null;
        int n = m.size();
        for (int i = 0; i < n; i++) {
          Method me = m.get(i);
          if (isStaticMethod(me) && call_checkArgs(me, args, false))
            return me;
        }
        return null;
      } catch (Exception __e) {
        throw rethrow(__e);
      }
    }
  }

  static public class Symbol implements CharSequence {

    public String text;

    public Symbol() {
    }

    public Symbol(String text, boolean dummy) {
      this.text = text;
    }

    public int hashCode() {
      return _hashCode(text);
    }

    public String toString() {
      return text;
    }

    public boolean equals(Object o) {
      return this == o;
    }

    public int length() {
      return text.length();
    }

    public char charAt(int index) {
      return text.charAt(index);
    }

    public CharSequence subSequence(int start, int end) {
      return text.substring(start, end);
    }
  }

  static public class VarContext {

    final public VarContext getParent() {
      return parent();
    }

    public VarContext parent() {
      return parent;
    }

    public VarContext parent;

    public Map<String, Object> vars;

    public VarContext() {
    }

    public VarContext(VarContext parent) {
      this.parent = parent;
    }

    public Object get(String name) {
      if (containsKey(vars, name))
        return mapGet(vars, name);
      if (parent != null)
        return parent.get(name);
      return null;
    }

    final public void put(String name, Object value) {
      set(name, value);
    }

    public void set(String name, Object value) {
      vars = putOrCreateSyncMap(vars, name, value);
    }

    final public AutoCloseable tempPut(String name, Object value) {
      return tempSet(name, value);
    }

    public AutoCloseable tempSet(String name, Object value) {
      initMap();
      return main.tempPut(vars, name, value);
    }

    public void unset(String name) {
      remove(vars, name);
    }

    public void printMe() {
      pnl(vars);
      print("parent", parent);
    }

    final public void initMap() {
      makeThreadSafe();
    }

    public void makeThreadSafe() {
      if (vars == null)
        vars = syncHashMap();
    }

    final public VarContext setExitFromScript(Object exitFromScript) {
      return exitFromScript(exitFromScript);
    }

    public VarContext exitFromScript(Object exitFromScript) {
      this.exitFromScript = exitFromScript;
      return this;
    }

    final public Object getExitFromScript() {
      return exitFromScript();
    }

    public Object exitFromScript() {
      return exitFromScript;
    }

    public Object exitFromScript;

    final public VarContext setReturnValue(Object returnValue) {
      return returnValue(returnValue);
    }

    public VarContext returnValue(Object returnValue) {
      this.returnValue = returnValue;
      return this;
    }

    final public Object getReturnValue() {
      return returnValue();
    }

    public Object returnValue() {
      return returnValue;
    }

    public Object returnValue;

    public boolean exiting() {
      ping();
      return exitFromScript != null;
    }
  }

  static public interface IMeta {

    public void _setMeta(Object meta);

    public Object _getMeta();

    default public IAutoCloseableF0 _tempMetaMutex() {
      return new IAutoCloseableF0() {

        public Object get() {
          return IMeta.this;
        }

        public void close() {
        }
      };
    }

    default public Object getMeta(Object obj, Object key) {
      return metaGet(obj, key);
    }

    default public Object metaGet(Object obj, Object key) {
      return metaMapGet(obj, key);
    }

    default public Object metaGet(String key, Object obj) {
      return metaMapGet(obj, key);
    }

    default public Object getMeta(Object key) {
      return metaGet(key);
    }

    default public Object metaGet(Object key) {
      if (key == null)
        return null;
      Object meta = _getMeta();
      if (meta instanceof Map)
        return ((Map) meta).get(key);
      return null;
    }

    default public void metaSet(IMeta obj, Object key, Object value) {
      metaPut(obj, key, value);
    }

    default public void metaPut(IMeta obj, Object key, Object value) {
      metaMapPut(obj, key, value);
    }

    default public void metaSet(Object key, Object value) {
      metaPut(key, value);
    }

    default public void metaPut(Object key, Object value) {
      if (key == null)
        return;
      Map map = convertObjectMetaToMap(this);
      syncMapPutOrRemove(map, key, value);
    }
  }

  static public class BetterThread extends Thread {

    public Runnable target;

    public BetterThread(Runnable target) {
      this.target = target;
      _created();
    }

    public BetterThread(Runnable target, String name) {
      super(name);
      this.target = target;
      _created();
    }

    public void _created() {
      vmBus_send("threadCreated", this);
    }

    public void run() {
      try {
        try {
          vmBus_send("threadStarted", this);
          if (target != null)
            target.run();
        } finally {
          vmBus_send("threadEnded", this);
        }
      } catch (Exception __e) {
        throw rethrow(__e);
      }
    }

    public Runnable getTarget() {
      return target;
    }
  }

  static public interface ITokCondition {

    public boolean get(List<String> tok, int i);
  }

  static public class LASClassLoader extends InMemoryClassLoader {

    public Map<String, Class> definedClasses = new HashMap();

    public Lock lock = lock();

    public LASClassLoader(ClassLoader parent) {
      super(parent);
    }

    public LASClassLoader(Class parent) {
      super(parent.getClassLoader());
    }

    public Class<?> defineLASClass(String name, IF0<byte[]> generateClass) {
      Lock __0 = lock;
      lock(__0);
      try {
        try {
          return loadClass(name);
        } catch (ClassNotFoundException e) {
          print("Generating class " + name);
          return defineAClass(name, generateClass.get());
        }
      } finally {
        unlock(__0);
      }
    }
  }

  static abstract public class TokCondition implements ITokCondition {

    public abstract boolean get(List<String> tok, int i);
  }

  static public class GazelleV_LeftArrowScriptParser extends SimpleLeftToRightParser {

    final public GazelleV_LeftArrowScriptParser setG22utils(G22Utils g22utils) {
      return g22utils(g22utils);
    }

    public GazelleV_LeftArrowScriptParser g22utils(G22Utils g22utils) {
      this.g22utils = g22utils;
      return this;
    }

    final public G22Utils getG22utils() {
      return g22utils();
    }

    public G22Utils g22utils() {
      return g22utils;
    }

    public G22Utils g22utils = new G22Utils();

    public List functionContainers = new ArrayList();

    final public GazelleV_LeftArrowScriptParser setLasClassLoader(LASClassLoader lasClassLoader) {
      return lasClassLoader(lasClassLoader);
    }

    public GazelleV_LeftArrowScriptParser lasClassLoader(LASClassLoader lasClassLoader) {
      this.lasClassLoader = lasClassLoader;
      return this;
    }

    final public LASClassLoader getLasClassLoader() {
      return lasClassLoader();
    }

    public LASClassLoader lasClassLoader() {
      return lasClassLoader;
    }

    public LASClassLoader lasClassLoader;

    final public GazelleV_LeftArrowScriptParser setClassDefPrefix(String classDefPrefix) {
      return classDefPrefix(classDefPrefix);
    }

    public GazelleV_LeftArrowScriptParser classDefPrefix(String classDefPrefix) {
      this.classDefPrefix = classDefPrefix;
      return this;
    }

    final public String getClassDefPrefix() {
      return classDefPrefix();
    }

    public String classDefPrefix() {
      return classDefPrefix;
    }

    public String classDefPrefix;

    public LinkedHashMap<String, LASValueDescriptor> knownVars = new LinkedHashMap();

    public Set<String> closerTokens = litset(";", "}", ")");

    public BuildingScript currentReturnableScript;

    public BuildingScript currentLoop;

    public boolean inParens = false;

    public int idCounter;

    public Map<String, LASClassDef> classDefs = new HashMap();

    transient public Set<IVF1<Map<String, LASValueDescriptor>>> onKnownVarsSnapshot;

    public GazelleV_LeftArrowScriptParser onKnownVarsSnapshot(IVF1<Map<String, LASValueDescriptor>> f) {
      onKnownVarsSnapshot = createOrAddToSyncLinkedHashSet(onKnownVarsSnapshot, f);
      return this;
    }

    public GazelleV_LeftArrowScriptParser removeKnownVarsSnapshotListener(IVF1<Map<String, LASValueDescriptor>> f) {
      main.remove(onKnownVarsSnapshot, f);
      return this;
    }

    public void knownVarsSnapshot(Map<String, LASValueDescriptor> knownVars) {
      if (onKnownVarsSnapshot != null)
        for (var listener : onKnownVarsSnapshot) pcallF_typed(listener, knownVars);
    }

    static public class MethodOnObject implements IFieldsToList {

      static final public String _fieldOrder = "object method";

      public Object object;

      public String method;

      public MethodOnObject() {
      }

      public MethodOnObject(Object object, String method) {
        this.method = method;
        this.object = object;
      }

      public String toString() {
        return shortClassName_dropNumberPrefix(this) + "(" + object + ", " + method + ")";
      }

      public boolean equals(Object o) {
        if (!(o instanceof MethodOnObject))
          return false;
        MethodOnObject __12 = (MethodOnObject) o;
        return eq(object, __12.object) && eq(method, __12.method);
      }

      public int hashCode() {
        int h = 791808543;
        h = boostHashCombine(h, _hashCode(object));
        h = boostHashCombine(h, _hashCode(method));
        return h;
      }

      public Object[] _fieldsToList() {
        return new Object[] { object, method };
      }
    }

    static public class EvaluableWrapper implements IFieldsToList {

      public GazelleV_LeftArrowScript.Evaluable expr;

      public EvaluableWrapper() {
      }

      public EvaluableWrapper(GazelleV_LeftArrowScript.Evaluable expr) {
        this.expr = expr;
      }

      public String toString() {
        return shortClassName_dropNumberPrefix(this) + "(" + expr + ")";
      }

      public boolean equals(Object o) {
        if (!(o instanceof EvaluableWrapper))
          return false;
        EvaluableWrapper __13 = (EvaluableWrapper) o;
        return eq(expr, __13.expr);
      }

      public int hashCode() {
        int h = 700525824;
        h = boostHashCombine(h, _hashCode(expr));
        return h;
      }

      public Object[] _fieldsToList() {
        return new Object[] { expr };
      }
    }

    public class BuildingScript {

      public int id = ++idCounter;

      public boolean returnable, isLoopBody;

      public BuildingScript returnableParent, loopParent;

      public GazelleV_LeftArrowScript.Script script = new GazelleV_LeftArrowScript.Script();

      public List<GazelleV_LeftArrowScript.Evaluable> steps = new ArrayList();

      public Map<String, GazelleV_LeftArrowScript.FunctionDef> functionDefs = new HashMap();

      public BuildingScript(boolean returnable) {
        this.returnable = returnable;
      }

      public BuildingScript(boolean returnable, boolean isLoopBody) {
        this.isLoopBody = isLoopBody;
        this.returnable = returnable;
      }

      public void add(GazelleV_LeftArrowScript.Evaluable step) {
        if (step != null)
          steps.add(step);
      }

      public GazelleV_LeftArrowScript.Evaluable get() {
        var lastStep = last(steps);
        if (lastStep instanceof GazelleV_LeftArrowScript.ReturnFromScript)
          if (((GazelleV_LeftArrowScript.ReturnFromScript) lastStep).script == script)
            replaceLast(steps, ((GazelleV_LeftArrowScript.ReturnFromScript) lastStep).value);
        if (!returnable && l(steps) == 1 && empty(functionDefs))
          return first(steps);
        script.functionDefs = functionDefs;
        script.steps = toTypedArray(GazelleV_LeftArrowScript.Evaluable.class, steps);
        return script;
      }

      public String toStringLong() {
        return pnlToLines(steps);
      }

      public String toString() {
        return formatRecordVars("BuildingScript", "id", id, "returnable", returnable, "returnableParent", returnableParent, "script", script);
      }
    }

    public GazelleV_LeftArrowScript.Script parse(String text) {
      setText(text);
      init();
      return parse();
    }

    public GazelleV_LeftArrowScript.Script parse() {
      return parseReturnableScript();
    }

    public GazelleV_LeftArrowScript.Script parseReturnableScript() {
      return (GazelleV_LeftArrowScript.Script) parseScript(true);
    }

    public GazelleV_LeftArrowScript.Evaluable parseScript(boolean returnable) {
      return parseScript(returnable, false);
    }

    public GazelleV_LeftArrowScript.Evaluable parseScript(boolean returnable, boolean isLoopBody) {
      return linkToSrc(() -> {
        BuildingScript script = new BuildingScript(returnable, isLoopBody);
        script.returnableParent = currentReturnableScript;
        script.loopParent = currentLoop;
        if (returnable)
          currentReturnableScript = script;
        if (isLoopBody)
          currentLoop = script;
        return parseBuildingScript(script);
      });
    }

    public GazelleV_LeftArrowScript.Evaluable parseBuildingScript(BuildingScript script) {
      try {
        parseScript_2(script);
        var builtScript = script.get();
        currentReturnableScript = script.returnableParent;
        currentLoop = script.loopParent;
        return builtScript;
      } catch (Throwable e) {
        if (GazelleV_LeftArrowScriptParser.this.scaffoldingEnabled())
          print("Parsed so far:\n" + script);
        throw rethrowAndAppendToMessage(e, squareBracketed(str(lineAndColumn(-1))));
      }
    }

    public void parseScript_2(BuildingScript script) {
      AutoCloseable __4 = tempRestoreMap(knownVars);
      try {
        AssureAdvance assure = new AssureAdvance();
        while (assure.get()) {
          knownVarsSnapshot(knownVars);
          if (GazelleV_LeftArrowScriptParser.this.scaffoldingEnabled())
            print("parseScript_2: Next token is " + quote(token()));
          if (is(";")) {
            next();
            continue;
          }
          if (isOneOf("}", ")"))
            break;
          GazelleV_LeftArrowScript.Evaluable instruction = linkToSrc(() -> parseInstruction(script));
          if (instruction != null)
            script.add(instruction);
        }
        if (GazelleV_LeftArrowScriptParser.this.scaffoldingEnabled())
          print("parseScript_2 done");
        knownVarsSnapshot(knownVars);
      } finally {
        _close(__4);
      }
    }

    public GazelleV_LeftArrowScript.Evaluable parseInstruction(BuildingScript script) {
      if (is("def")) {
        parseFunctionDefinition(currentReturnableScript.functionDefs);
        return null;
      }
      if (is("param")) {
        consume();
        String var = assertIdentifier(tpp());
        knownVars.put(var, new LASValueDescriptor());
        return null;
      }
      if (is("throw")) {
        consume();
        return new GazelleV_LeftArrowScript.Throw(parseExpr());
      }
      if (is("try")) {
        consume();
        GazelleV_LeftArrowScript.Evaluable body = parseCurlyBlock(false);
        consume("catch");
        String var = consumeIdentifier();
        AutoCloseable __5 = tempAddKnownVars(var);
        try {
          GazelleV_LeftArrowScript.Evaluable catchBlock = parseCurlyBlock(false);
          return new GazelleV_LeftArrowScript.TryCatch(body, var, catchBlock);
        } finally {
          _close(__5);
        }
      }
      if (isOneOf("return", "ret")) {
        consume();
        GazelleV_LeftArrowScript.Evaluable expr;
        if (atCmdEnd())
          expr = _const(null);
        else
          expr = parseAssignmentOrExpr();
        return new GazelleV_LeftArrowScript.ReturnFromScript(currentReturnableScript.script, expr);
      }
      if (is("continue")) {
        consume();
        assertCmdEnd();
        if (currentLoop == null)
          throw fail("continue outside of loop");
        return new GazelleV_LeftArrowScript.Continue(currentLoop.script);
      }
      if (is("temp")) {
        consume();
        GazelleV_LeftArrowScript.Evaluable tempExpr = parseExpr();
        if (GazelleV_LeftArrowScriptParser.this.scaffoldingEnabled())
          print("tempExpr", tempExpr);
        GazelleV_LeftArrowScript.Evaluable body = parseScript(false);
        if (GazelleV_LeftArrowScriptParser.this.scaffoldingEnabled())
          print("body", body);
        return new GazelleV_LeftArrowScript.TempBlock(tempExpr, body);
      }
      if (is("class"))
        return new GazelleV_LeftArrowScript.ClassDef(new ResolvableLASClass(lasClassLoader, parseClassDef()));
      return parseAssignmentOrExpr();
    }

    public GazelleV_LeftArrowScript.Evaluable parseAssignmentOrExpr() {
      {
        var __2 = parseAssignmentOpt();
        if (__2 != null)
          return __2;
      }
      return parseExpr();
    }

    public GazelleV_LeftArrowScript.Evaluable parseAssignmentOpt() {
      String t = token();
      if (isIdentifier(t) && eq(token(1), "<") && eq(token(2), "-")) {
        if (GazelleV_LeftArrowScriptParser.this.scaffoldingEnabled())
          print("Found assignment");
        next(3);
        GazelleV_LeftArrowScript.Evaluable rhs = parseExpr();
        assertNotNull("Expression expected", rhs);
        boolean newVar = !knownVars.containsKey(t);
        if (GazelleV_LeftArrowScriptParser.this.scaffoldingEnabled())
          printVars("newVar", newVar, "t", t, "knownVars", knownVars);
        knownVars.put(t, new LASValueDescriptor());
        return newVar ? new GazelleV_LeftArrowScript.VarDeclaration(t, null, rhs) : new GazelleV_LeftArrowScript.Assignment(t, rhs);
      }
      return null;
    }

    public GazelleV_LeftArrowScript.Evaluable parseOptionalInnerExpression() {
      if (GazelleV_LeftArrowScriptParser.this.scaffoldingEnabled())
        printVars("parseOptionalInnerExpression", "token", token());
      if (atCmdEnd() || isOneOf("{", ","))
        return null;
      return parseInnerExpr();
    }

    public GazelleV_LeftArrowScript.Evaluable _const(Object o) {
      return new GazelleV_LeftArrowScript.Const(o);
    }

    public GazelleV_LeftArrowScript.Evaluable parseInnerExpr() {
      return parseExpr(true);
    }

    public GazelleV_LeftArrowScript.Evaluable parseExpr() {
      if (metaGet("scaffolding") != null)
        scaffoldCalled(this, "parseExpr");
      return parseExpr(false);
    }

    public GazelleV_LeftArrowScript.Evaluable parseExpr(boolean inner) {
      return printIndentedStructIf(scaffoldingEnabled(), "parseExpr done", linkToSrc(() -> inner ? parseExpr_impl(true) : parseExprPlusOptionalComma()));
    }

    public GazelleV_LeftArrowScript.Evaluable parseExprPlusOptionalComma() {
      GazelleV_LeftArrowScript.Evaluable expr = parseExpr_impl(false);
      while (consumeOpt(",")) {
        expr = parseCall(expr);
      }
      return expr;
    }

    public GazelleV_LeftArrowScript.Evaluable parseExpr_impl(boolean inner) {
      if (atEnd())
        return null;
      String t = token();
      if (GazelleV_LeftArrowScriptParser.this.scaffoldingEnabled())
        printVars("parseExpr", "token", t);
      if (is(";"))
        return null;
      if (is("{"))
        return parseCurlyBlock(false);
      if (is("-") && empty(nextSpace()) && startsWithDigit(token(1)) || startsWithDigit(t)) {
        var e = parseNumberLiteral();
        return inner ? e : parseCall(e);
      }
      if (isQuoted(t)) {
        consume();
        var e = _const(unquote(t));
        return inner ? e : parseCall(e);
      }
      if (isIdentifier(t)) {
        if (is("while"))
          return parseWhileLoop();
        if (is("for"))
          return parseForEach();
        if (is("if"))
          return parseIfStatement();
        if (is("repeat"))
          return parseRepeatStatement();
        if (is("outer")) {
          consume();
          var a = parseAssignmentOpt();
          if (!(a instanceof GazelleV_LeftArrowScript.Assignment))
            throw fail("Assignment expected");
          return new GazelleV_LeftArrowScript.AssignmentToOuterVar(((GazelleV_LeftArrowScript.Assignment) a).var, ((GazelleV_LeftArrowScript.Assignment) a).expression);
        }
        consume();
        if (GazelleV_LeftArrowScriptParser.this.scaffoldingEnabled())
          print("Consumed identifier " + t + ", next token: " + token() + ", inner: " + inner);
        return parseExprStartingWithIdentifier(t, inner);
      }
      if (eq(t, "(")) {
        boolean inParensOld = inParens;
        inParens = true;
        consume();
        var e = parseExpr();
        consume(")");
        inParens = inParensOld;
        return inner ? e : parseCall(e);
      }
      if (isOneOf("&", "|") && empty(nextSpace()) && is(1, token())) {
        return parseBinaryOperator();
      }
      throw fail("Identifier, literal, operator or opening parentheses expected (got: " + quote(t));
    }

    public GazelleV_LeftArrowScript.Evaluable parseNumberLiteral() {
      String t = consumeMultiTokenLiteral();
      if (swic(t, "0x"))
        return _const(parseHexInt(dropFirst(t, 2)));
      if (swic(t, "0b"))
        return _const(intFromBinary(dropFirst(t, 2)));
      if (isInteger(t))
        return _const(parseInt(t));
      if (endsWith(t, "f"))
        return _const(parseFloat(t));
      if (endsWith(t, "L"))
        return _const(parseLong(t));
      return _const(parseDouble(t));
    }

    public GazelleV_LeftArrowScript.Evaluable parseBinaryOperator() {
      boolean and = is("&");
      next(2);
      GazelleV_LeftArrowScript.Evaluable a = parseInnerExpr();
      GazelleV_LeftArrowScript.Evaluable b = parseInnerExpr();
      return and ? new GazelleV_LeftArrowScript.BoolAnd(a, b) : new GazelleV_LeftArrowScript.BoolOr(a, b);
    }

    public boolean qualifiedNameContinues() {
      return empty(prevSpace()) && eq(token(), ".") && empty(nextSpace()) && isIdentifier(token(1));
    }

    public GazelleV_LeftArrowScript.Evaluable parseExprStartingWithIdentifier(String t, boolean inner) {
      if (eq(t, "true"))
        return _const(true);
      if (eq(t, "false"))
        return _const(false);
      if (eq(t, "null"))
        return _const(null);
      if (eq(t, "new")) {
        String className = assertIdentifier(tpp());
        LASClassDef cd = classDefs.get(className);
        if (cd != null)
          return new GazelleV_LeftArrowScript.NewObject_LASClass(new ResolvableLASClass(lasClassLoader, cd));
        var type = knownVars.get(className);
        if (type != null)
          return new GazelleV_LeftArrowScript.NewObject_UnknownClass(new GazelleV_LeftArrowScript.GetVar(className), parseArguments());
        Object o = findExternalObject(className);
        if (o instanceof Class) {
          Class c = (Class) o;
          if (c == List.class)
            c = ArrayList.class;
          else if (c == Map.class)
            c = HashMap.class;
          else if (c == Set.class)
            c = HashSet.class;
          return new GazelleV_LeftArrowScript.NewObject(c, parseArguments());
        }
        throw new ClassNotFound(className);
      }
      var type = knownVars.get(t);
      if (type != null) {
        var e = new GazelleV_LeftArrowScript.GetVar(t).returnType(type);
        if (GazelleV_LeftArrowScriptParser.this.scaffoldingEnabled())
          print("Found var acccess: " + e + ", " + (!inner ? "Checking for call" : "Returning expression"));
        return inner ? e : parseCall(e);
      }
      if (!inner) {
        var fdef = lookupFunction(t);
        if (fdef != null)
          return new GazelleV_LeftArrowScript.CallFunction(fdef, parseArguments());
      }
      if (eq(t, "_context"))
        return new GazelleV_LeftArrowScript.GetVarContext();
      Object o = findExternalObject(t);
      if (o == null) {
        throw new UnknownObject(t);
      } else if (o instanceof EvaluableWrapper) {
        return inner ? ((EvaluableWrapper) o).expr : parseCall(((EvaluableWrapper) o).expr);
      } else if (inner)
        return _const(o);
      else if (o instanceof Class) {
        return parseExprStartingWithClass((Class) o);
      } else if (o instanceof MethodOnObject) {
        if (inner)
          throw fail("Can't call methods in arguments");
        return new GazelleV_LeftArrowScript.CallMethod(_const(((MethodOnObject) o).object), ((MethodOnObject) o).method, parseArguments());
      } else
        return parseCall(_const(o));
    }

    public GazelleV_LeftArrowScript.Evaluable parseExprStartingWithClass(Class c) {
      if (atCmdEnd())
        return _const(c);
      if (is("("))
        return new GazelleV_LeftArrowScript.NewObject(c, parseArguments());
      {
        var __3 = parseLambdaOpt(c);
        if (__3 != null)
          return __3;
      }
      if (isIdentifier()) {
        String name = tpp();
        if (hasMethodNamed(c, name))
          return new GazelleV_LeftArrowScript.CallMethod(_const(c), name, parseArguments());
        if (isInterface(c))
          return parseLambdaMethodRef(c, name);
        var field = getField(c, name);
        if (field != null) {
          assertCmdEnd();
          if (!isStaticField(field))
            throw fail(field + " is not a static field");
          return new GazelleV_LeftArrowScript.GetStaticField(field);
        }
        throw fail(name + " not found in " + c + " (looked for method or field)");
      } else
        throw fail("Method name expected: " + token());
    }

    public GazelleV_LeftArrowScript.Evaluable parseLambdaOpt(Class c) {
      int nArgs = 0;
      while (isIdentifier(token(nArgs))) nArgs++;
      if (!(is(nArgs, "-") && is(nArgs + 1, ">")))
        return null;
      String[] argNames = consumeArray(nArgs);
      AutoCloseable __6 = tempAddKnownVars(argNames);
      try {
        skip(2);
        GazelleV_LeftArrowScript.Evaluable body;
        if (is("{"))
          body = parseReturnableScript();
        else
          body = parseExpr();
        return printIndentedStructIf(scaffoldingEnabled(), "parseLambdaOpt done", new GazelleV_LeftArrowScript.LambdaDef(c, argNames, body));
      } finally {
        _close(__6);
      }
    }

    public GazelleV_LeftArrowScript.Evaluable parseLambdaMethodRef(Class c, String name) {
      var fdef = lookupFunction(name);
      if (fdef != null) {
        GazelleV_LeftArrowScript.Evaluable[] curriedArguments = parseArguments();
        return new GazelleV_LeftArrowScript.CurriedScriptFunctionLambda(c, fdef, curriedArguments);
      }
      Object function = findExternalObject(name);
      if (function == null)
        throw new UnknownObject(name);
      if (function instanceof MethodOnObject) {
        Object target = ((MethodOnObject) function).object;
        String targetMethod = ((MethodOnObject) function).method;
        GazelleV_LeftArrowScript.Evaluable[] curriedArguments = parseArguments();
        return new GazelleV_LeftArrowScript.CurriedMethodLambda(c, target, targetMethod, curriedArguments);
      } else if (function instanceof Class) {
        Class c2 = (Class) function;
        assertCmdEnd();
        var ctors = constructorsWithNumberOfArguments(c2, 1);
        if (empty(ctors))
          throw fail("No single argument constructor found in " + c2);
        return new GazelleV_LeftArrowScript.CurriedConstructorLambda(c, toArray(Constructor.class, ctors), null);
      } else
        throw fail(function + " is not an instantiable class or callable method");
    }

    public GazelleV_LeftArrowScript.FunctionDef lookupFunction(String name) {
      var script = currentReturnableScript;
      while (script != null) {
        var f = script.functionDefs.get(name);
        if (GazelleV_LeftArrowScriptParser.this.scaffoldingEnabled())
          printVars("lookupFunction", "script", script, "name", name, "f", f);
        if (f != null)
          return f;
        script = script.returnableParent;
      }
      return null;
    }

    public GazelleV_LeftArrowScript.Evaluable[] parseArguments() {
      return toArrayOrNull(GazelleV_LeftArrowScript.Evaluable.class, parseArgumentsAsList());
    }

    public List<GazelleV_LeftArrowScript.Evaluable> parseArgumentsAsList() {
      List<GazelleV_LeftArrowScript.Evaluable> l = new ArrayList();
      try {
        while (true) {
          GazelleV_LeftArrowScript.Evaluable a = parseOptionalInnerExpression();
          if (a == null)
            break;
          l.add(a);
        }
        return l;
      } catch (Throwable _e) {
        if (GazelleV_LeftArrowScriptParser.this.scaffoldingEnabled())
          print("Arguments parsed so far: " + l);
        throw rethrow(_e);
      }
    }

    public String consumeMultiTokenLiteral() {
      return consumeUntilSpaceOr(() -> atCmdEnd() || is(","));
    }

    public boolean atCmdEnd() {
      return !inParens && atEndOrLineBreak() || closerTokens.contains(token());
    }

    public void assertCmdEnd() {
      if (!atCmdEnd())
        throw fail("Expected end of command, token is: " + quote(token()));
    }

    public GazelleV_LeftArrowScript.Evaluable parseCall(GazelleV_LeftArrowScript.Evaluable target) {
      if (atCmdEnd() || !isIdentifier())
        return target;
      var start = ptr();
      String name = tpp();
      if (eq(token(), "<") && eq(token(1), "-")) {
        next(2);
        GazelleV_LeftArrowScript.Evaluable rhs = parseExpr();
        return new GazelleV_LeftArrowScript.SetField(target, name, rhs);
      }
      var args = parseArguments();
      if (nempty(args))
        return new GazelleV_LeftArrowScript.CallMethod(target, name, args);
      else
        return linkToSrc(start, new GazelleV_LeftArrowScript.CallMethodOrGetField(target, name));
    }

    public <A> A linkToSrc(ListAndIndex<String> start, A a) {
      if (a instanceof IHasTokenRangeWithSrc)
        ((IHasTokenRangeWithSrc) a).setTokenRangeWithSrc(new TokenRangeWithSrc(start, ptr().plus(-1)));
      return a;
    }

    public <A> A linkToSrc(IF0<A> a) {
      var start = ptr();
      return linkToSrc(start, a.get());
    }

    transient public IF1<String, Object> findExternalObject;

    public Object findExternalObject(String name) {
      return findExternalObject != null ? findExternalObject.get(name) : findExternalObject_base(name);
    }

    final public Object findExternalObject_fallback(IF1<String, Object> _f, String name) {
      return _f != null ? _f.get(name) : findExternalObject_base(name);
    }

    public Object findExternalObject_base(String name) {
      if (qualifiedNameContinues()) {
        int idx = idx() - 2;
        do next(2); while (qualifiedNameContinues());
        String fqn = joinSubList(tok, idx, idx() - 1);
        return classForName(fqn);
      }
      String fullName = globalClassNames().get(name);
      if (fullName != null)
        return classForName(fullName);
      for (var container : unnullForIteration(functionContainers)) {
        if (hasMethodNamed(container, name))
          return new MethodOnObject(container, name);
        var field = getField(container, name);
        if (field != null && isStaticField(field))
          return new EvaluableWrapper(new GazelleV_LeftArrowScript.GetStaticField(field));
      }
      return null;
    }

    public GazelleV_LeftArrowScriptParser allowTheWorld() {
      return allowTheWorld(mc());
    }

    public GazelleV_LeftArrowScriptParser allowTheWorld(Object... functionContainers) {
      for (Object o : unnullForIteration(reversed(functionContainers))) if (!contains(this.functionContainers, o)) {
        this.functionContainers.add(0, o);
        globalClassNames_cache = null;
      }
      return this;
    }

    public void printFunctionDefs(GazelleV_LeftArrowScript.Script script) {
      if (GazelleV_LeftArrowScriptParser.this.scaffoldingEnabled())
        print(values(script.functionDefs));
    }

    public AutoCloseable tempAddKnownVars(String... vars) {
      return tempAddKnownVars(asList(vars));
    }

    public AutoCloseable tempAddKnownVars(Iterable<String> vars) {
      return tempMapPutAll(knownVars, mapWithSingleValue(vars, new LASValueDescriptor()));
    }

    public GazelleV_LeftArrowScript.FunctionDef parseFunctionDefinition(Map<String, GazelleV_LeftArrowScript.FunctionDef> functionDefsToAddTo) {
      consume("def");
      String functionName = assertIdentifier(tpp());
      if (GazelleV_LeftArrowScriptParser.this.scaffoldingEnabled())
        print("parseFunctionDefinition " + functionName);
      List<String> args = new ArrayList();
      while (isIdentifier()) args.add(tpp());
      AutoCloseable __7 = tempAddKnownVars(args);
      try {
        if (GazelleV_LeftArrowScriptParser.this.scaffoldingEnabled())
          print("Parsing function body");
        var functionBody = parseReturnableCurlyBlock();
        if (GazelleV_LeftArrowScriptParser.this.scaffoldingEnabled())
          print("Defined function " + functionName + ", adding to " + functionDefsToAddTo);
        var fd = new GazelleV_LeftArrowScript.FunctionDef(functionName, args, functionBody);
        {
          if (functionDefsToAddTo != null)
            functionDefsToAddTo.put(functionName, fd);
        }
        return fd;
      } finally {
        _close(__7);
      }
    }

    public GazelleV_LeftArrowScript.Script parseReturnableCurlyBlock() {
      return (GazelleV_LeftArrowScript.Script) parseCurlyBlock(true);
    }

    public GazelleV_LeftArrowScript.Evaluable parseCurlyBlock(boolean returnable) {
      return parseCurlyBlock(returnable, false);
    }

    public GazelleV_LeftArrowScript.Evaluable parseCurlyBlock(boolean returnable, boolean isLoopBody) {
      consume("{");
      boolean inParensOld = inParens;
      inParens = false;
      var body = parseScript(returnable, isLoopBody);
      consume("}");
      inParens = inParensOld;
      return body;
    }

    public GazelleV_LeftArrowScript.Evaluable parseWhileLoop() {
      consume("while");
      var condition = parseExpr();
      var body = parseCurlyBlock(false, true);
      return new GazelleV_LeftArrowScript.While(condition, body);
    }

    public GazelleV_LeftArrowScript.Evaluable parseForEach() {
      return new ParseForEach().get();
    }

    public class ParseForEach {

      public GazelleV_LeftArrowScript.Evaluable collection, body;

      public IF0<GazelleV_LeftArrowScript.Evaluable> finish;

      public IF0<AutoCloseable> enterBody;

      public GazelleV_LeftArrowScript.Evaluable get() {
        consume("for");
        int iIn = relativeIndexOf("in");
        if (iIn < 0)
          throw fail("for without in");
        if (GazelleV_LeftArrowScriptParser.this.scaffoldingEnabled())
          print("iIn", iIn);
        if (iIn == 1) {
          String var = consumeIdentifier();
          enterBody = () -> tempAddKnownVars(var);
          finish = () -> new GazelleV_LeftArrowScript.ForEach(collection, var, body);
        } else if (iIn == 2) {
          if (consumeOpt("iterator")) {
            String var = consumeIdentifier();
            enterBody = () -> tempAddKnownVars(var);
            finish = () -> new GazelleV_LeftArrowScript.ForIterator(collection, var, body);
          } else if (consumeOpt("nested")) {
            String var = consumeIdentifier();
            enterBody = () -> tempAddKnownVars(var);
            finish = () -> new GazelleV_LeftArrowScript.ForNested(collection, var, body);
          } else
            throw fail("Unknown pattern for 'for' loop");
        } else if (iIn == 3) {
          if (isOneOf("pair", "Pair")) {
            consume();
            String varA = consumeIdentifier();
            String varB = consumeIdentifier();
            if (GazelleV_LeftArrowScriptParser.this.scaffoldingEnabled())
              printVars("varA", varA, "varB", varB);
            enterBody = () -> tempAddKnownVars(varA, varB);
            finish = () -> new GazelleV_LeftArrowScript.ForPairs(collection, body, varA, varB);
          } else {
            String varA = consumeIdentifier();
            consume(",");
            String varB = consumeIdentifier();
            enterBody = () -> tempAddKnownVars(varA, varB);
            finish = () -> new GazelleV_LeftArrowScript.ForKeyValue(collection, body, varA, varB);
          }
        } else if (iIn == 4) {
          consume("index");
          String varIndex = consumeIdentifier();
          consume(",");
          String varElement = consumeIdentifier();
          enterBody = () -> tempAddKnownVars(varIndex, varElement);
          finish = () -> new GazelleV_LeftArrowScript.ForIndex(collection, body, varIndex, varElement);
        } else
          throw fail("Unknown pattern for 'for' loop");
        consume("in");
        collection = parseExpr();
        if (GazelleV_LeftArrowScriptParser.this.scaffoldingEnabled())
          print("collection", collection);
        AutoCloseable __8 = enterBody.get();
        try {
          body = parseCurlyBlock(false, true);
          return finish.get();
        } finally {
          _close(__8);
        }
      }
    }

    public GazelleV_LeftArrowScript.Evaluable parseIfStatement() {
      consume("if");
      GazelleV_LeftArrowScript.Evaluable condition, body, elseBranch = null;
      {
        AutoCloseable __9 = tempAdd(closerTokens, "then");
        try {
          condition = parseExpr();
        } finally {
          _close(__9);
        }
      }
      if (consumeOpt("then")) {
        AutoCloseable __10 = tempAdd(closerTokens, "else");
        try {
          body = parseExpr();
          if (consumeOpt("else"))
            elseBranch = parseExpr();
        } finally {
          _close(__10);
        }
      } else {
        body = parseCurlyBlock(false);
        if (consumeOpt("else")) {
          if (is("if"))
            elseBranch = parseIfStatement();
          else
            elseBranch = parseCurlyBlock(false);
        }
      }
      return new GazelleV_LeftArrowScript.IfThen(condition, body, elseBranch);
    }

    public GazelleV_LeftArrowScript.Evaluable parseRepeatStatement() {
      consume("repeat");
      var n = parseExpr();
      var body = parseCurlyBlock(false);
      return new GazelleV_LeftArrowScript.RepeatN(n, body);
    }

    public void addVar(String var) {
      addVar(var, new LASValueDescriptor());
    }

    public void addVar(String var, LASValueDescriptor type) {
      knownVars.put(var, type);
    }

    public void addVar(String var, Class type, boolean canBeNull) {
      addVar(var, new LASValueDescriptor.NonExact(type, canBeNull));
    }

    public Map<String, String> globalClassNames_cache;

    public Map<String, String> globalClassNames() {
      if (globalClassNames_cache == null)
        globalClassNames_cache = globalClassNames_load();
      return globalClassNames_cache;
    }

    public Map<String, String> globalClassNames_load() {
      var packages = mapToTreeSet(importedPackages(), pkg -> pkg + ".");
      Map<String, String> out = new HashMap();
      for (var fc : functionContainers) if (fc instanceof Class) {
        if (isAnonymousClass((Class) fc))
          continue;
        out.put(shortClassName((Class) fc), className((Class) fc));
      }
      var classContainers = classContainerPrefixes();
      out.put("List", "java.util.List");
      for (var className : g22utils.classNameResolver().allFullyQualifiedClassNames()) {
        if (isAnonymousClassName(className))
          continue;
        if (!contains(className, '$')) {
          String pkg = longestPrefixInTreeSet(className, packages);
          if (pkg != null) {
            String shortName = dropPrefix(pkg, className);
            if (!shortName.contains(".") && !out.containsKey(shortName))
              out.put(shortName, className);
          }
        }
        String container = longestPrefixInTreeSet(className, classContainers);
        if (container != null)
          out.put(dropPrefix(container, className), className);
      }
      for (var __0 : _entrySet(javaxClassShortcuts())) {
        var key = __0.getKey();
        var val = __0.getValue();
        String fullName = out.get(val);
        if (fullName != null)
          out.put(key, fullName);
      }
      return out;
    }

    transient public IF0<Collection<String>> importedPackages;

    public Collection<String> importedPackages() {
      return importedPackages != null ? importedPackages.get() : importedPackages_base();
    }

    final public Collection<String> importedPackages_fallback(IF0<Collection<String>> _f) {
      return _f != null ? _f.get() : importedPackages_base();
    }

    public Collection<String> importedPackages_base() {
      return itemPlus("java.lang", standardImports_fullyImportedPackages());
    }

    public TreeSet<String> classContainerPrefixes() {
      return mapToTreeSet(functionContainers, fc -> className(fc) + "$");
    }

    static public class UnknownObject extends RuntimeException implements IFieldsToList {

      public String name;

      public UnknownObject() {
      }

      public UnknownObject(String name) {
        this.name = name;
      }

      public String toString() {
        return shortClassName_dropNumberPrefix(this) + "(" + name + ")";
      }

      public Object[] _fieldsToList() {
        return new Object[] { name };
      }

      public String getMessage() {
        return "Unknown object: " + name;
      }
    }

    static public class ClassNotFound extends UnknownObject {

      public ClassNotFound(String className) {
        super(className);
      }

      public String getMessage() {
        return "Class not found: " + name;
      }
    }

    public LASClassDef parseClassDef() {
      consume("class");
      LASClassDef classDef = new LASClassDef();
      classDef.verbose(scaffoldingEnabled());
      if (nempty(classDefPrefix))
        classDef.classDefPrefix(classDefPrefix);
      String name = consumeIdentifier();
      classDef.userGivenName(name);
      consume("{");
      while (!is("}")) {
        if (is(";")) {
          next();
          continue;
        }
        if (is("def")) {
          AutoCloseable __11 = tempAddKnownVars("this");
          try {
            GazelleV_LeftArrowScript.FunctionDef fd = parseFunctionDefinition(null);
            if (GazelleV_LeftArrowScriptParser.this.scaffoldingEnabled())
              printVars("knownVarsAfterFunctionDef", knownVars);
            classDef.methods.add(fd);
            continue;
          } finally {
            _close(__11);
          }
        }
        LASClassDef.FieldDef fd = new LASClassDef.FieldDef();
        fd.name(consumeIdentifier());
        consume(":");
        String typeName = consumeIdentifier();
        Object type = findExternalObject(typeName);
        if (!(type instanceof Class))
          throw fail("Class not found: " + typeName);
        fd.type((Class) type);
        classDef.fields.add(fd);
      }
      consume("}");
      classDefs.put(name, classDef);
      return classDef;
    }

    transient public IF1<String, Class> classForName;

    public Class classForName(String name) {
      return classForName != null ? classForName.get(name) : classForName_base(name);
    }

    final public Class classForName_fallback(IF1<String, Class> _f, String name) {
      return _f != null ? _f.get(name) : classForName_base(name);
    }

    public Class classForName_base(String name) {
      try {
        return Class.forName(name);
      } catch (Exception __e) {
        throw rethrow(__e);
      }
    }

    public void copyFunctionContainersFrom(GazelleV_LeftArrowScriptParser parser) {
      functionContainers = cloneList(parser.functionContainers);
      globalClassNames_cache = parser.globalClassNames();
    }
  }

  static public class PingSource {

    final public PingSource setAction(IF0<Boolean> action) {
      return action(action);
    }

    public PingSource action(IF0<Boolean> action) {
      this.action = action;
      return this;
    }

    final public IF0<Boolean> getAction() {
      return action();
    }

    public IF0<Boolean> action() {
      return action;
    }

    volatile public IF0<Boolean> action;

    public String text;

    public ThreadPool threadPool;

    public PingSource() {
    }

    public PingSource(ThreadPool threadPool) {
      this.threadPool = threadPool;
    }

    public PingSource(ThreadPool threadPool, String text) {
      this.text = text;
      this.threadPool = threadPool;
    }

    public PingSource(IF0<Boolean> action) {
      this.action = action;
    }

    final public boolean get() {
      var a = action;
      return a != null && a.get();
    }

    final public void ping() {
      var a = action;
      if (a != null)
        a.get();
    }

    public void cancel() {
      action = new Cancelled();
    }

    public class Cancelled implements IF0<Boolean> {

      public Boolean get() {
        throw new PingSourceCancelledException(PingSource.this);
      }
    }

    public class Encapsulated implements Runnable, IFieldsToList {

      public Runnable r;

      public Encapsulated() {
      }

      public Encapsulated(Runnable r) {
        this.r = r;
      }

      public Object[] _fieldsToList() {
        return new Object[] { r };
      }

      public void run() {
        try {
          try {
            pingSource_tl().set(PingSource.this);
            ping();
            r.run();
          } finally {
            pingSource_tl().set(null);
          }
        } catch (Exception __e) {
          throw rethrow(__e);
        }
      }

      public String toString() {
        return PingSource.this + ": " + r;
      }
    }

    public void dO(Runnable r) {
      if (r == null)
        return;
      threadPool.acquireThreadOrQueue(new Encapsulated(r));
    }

    public String toString() {
      String t = text;
      return nempty(t) ? t : super.toString();
    }

    public ISleeper_v2 sleeper() {
      return threadPool.sleeper();
    }
  }

  static public class MRUCache<A, B> extends LinkedHashMap<A, B> {

    public int maxSize = 10;

    public MRUCache() {
    }

    public MRUCache(int maxSize) {
      this.maxSize = maxSize;
    }

    public boolean removeEldestEntry(Map.Entry eldest) {
      return size() > maxSize;
    }

    public Object _serialize() {
      return ll(maxSize, cloneLinkedHashMap(this));
    }

    static public MRUCache _deserialize(List l) {
      MRUCache m = new MRUCache();
      m.maxSize = (int) first(l);
      m.putAll((LinkedHashMap) second(l));
      return m;
    }
  }

  static public class MultiMap<A, B> implements IMultiMap<A, B> {

    public Map<A, List<B>> data = new HashMap<A, List<B>>();

    public int fullSize;

    public MultiMap() {
    }

    public MultiMap(boolean useTreeMap) {
      if (useTreeMap)
        data = new TreeMap();
    }

    public MultiMap(MultiMap<A, B> map) {
      putAll(map);
    }

    public MultiMap(Map<A, List<B>> data) {
      this.data = data;
    }

    public void put(A key, B value) {
      synchronized (data) {
        List<B> list = data.get(key);
        if (list == null)
          data.put(key, list = _makeEmptyList());
        list.add(value);
        ++fullSize;
      }
    }

    public void add(A key, B value) {
      put(key, value);
    }

    public void addAll(A key, Collection<B> values) {
      putAll(key, values);
    }

    public void addAllIfNotThere(A key, Collection<B> values) {
      synchronized (data) {
        for (B value : values) setPut(key, value);
      }
    }

    public void setPut(A key, B value) {
      synchronized (data) {
        if (!containsPair(key, value))
          put(key, value);
      }
    }

    public boolean containsPair(A key, B value) {
      synchronized (data) {
        return get(key).contains(value);
      }
    }

    public void putAll(Collection<A> keys, B value) {
      synchronized (data) {
        for (A key : unnullForIteration(keys)) put(key, value);
      }
    }

    public void putAll(A key, Collection<B> values) {
      synchronized (data) {
        if (nempty(values))
          getActual(key).addAll(values);
      }
    }

    public void putAll(Iterable<Pair<A, B>> pairs) {
      synchronized (data) {
        for (Pair<A, B> p : unnullForIteration(pairs)) put(p.a, p.b);
      }
    }

    public void removeAll(A key, Collection<B> values) {
      synchronized (data) {
        for (B value : values) remove(key, value);
      }
    }

    public List<B> get(A key) {
      synchronized (data) {
        List<B> list = data.get(key);
        return list == null ? Collections.<B>emptyList() : list;
      }
    }

    public List<B> getOpt(A key) {
      synchronized (data) {
        return data.get(key);
      }
    }

    public List<B> getAndClear(A key) {
      synchronized (data) {
        List<B> l = cloneList(data.get(key));
        remove(key);
        return l;
      }
    }

    public List<B> getActual(A key) {
      synchronized (data) {
        List<B> list = data.get(key);
        if (list == null)
          data.put(key, list = _makeEmptyList());
        return list;
      }
    }

    public void clean(A key) {
      synchronized (data) {
        List<B> list = data.get(key);
        if (list != null && list.isEmpty()) {
          fullSize -= l(list);
          data.remove(key);
        }
      }
    }

    final public Set<A> keys() {
      return keySet();
    }

    public Set<A> keySet() {
      synchronized (data) {
        return data.keySet();
      }
    }

    public void remove(A key) {
      synchronized (data) {
        fullSize -= l(this.getOpt(key));
        data.remove(key);
      }
    }

    final public void remove(Pair<A, B> p) {
      removePair(p);
    }

    public void removePair(Pair<A, B> p) {
      if (p != null)
        remove(p.a, p.b);
    }

    public void remove(A key, B value) {
      synchronized (data) {
        List<B> list = data.get(key);
        if (list != null) {
          if (list.remove(value))
            fullSize--;
          if (list.isEmpty())
            data.remove(key);
        }
      }
    }

    public void clear() {
      synchronized (data) {
        data.clear();
      }
    }

    public boolean containsKey(A key) {
      synchronized (data) {
        return data.containsKey(key);
      }
    }

    public B getFirst(A key) {
      synchronized (data) {
        List<B> list = get(key);
        return list.isEmpty() ? null : list.get(0);
      }
    }

    public void addAll(MultiMap<A, B> map) {
      putAll(map);
    }

    public void putAll(MultiMap<A, B> map) {
      synchronized (data) {
        for (A key : map.keySet()) putAll(key, map.get(key));
      }
    }

    public void putAll(Map<A, B> map) {
      synchronized (data) {
        if (map != null)
          for (Map.Entry<A, B> e : map.entrySet()) put(e.getKey(), e.getValue());
      }
    }

    final public int keyCount() {
      return keysSize();
    }

    public int keysSize() {
      synchronized (data) {
        return l(data);
      }
    }

    final public int fullSize() {
      return size();
    }

    public int size() {
      synchronized (data) {
        return fullSize;
      }
    }

    public List<A> reverseGet(B b) {
      synchronized (data) {
        List<A> l = new ArrayList();
        for (A key : data.keySet()) if (data.get(key).contains(b))
          l.add(key);
        return l;
      }
    }

    public Map<A, List<B>> asMap() {
      synchronized (data) {
        return cloneMap(data);
      }
    }

    public boolean isEmpty() {
      synchronized (data) {
        return data.isEmpty();
      }
    }

    public List<B> _makeEmptyList() {
      return new ArrayList();
    }

    public Collection<List<B>> allLists() {
      synchronized (data) {
        return new ArrayList(data.values());
      }
    }

    public Collection<List<B>> values() {
      return allLists();
    }

    public List<B> allValues() {
      return concatLists(data.values());
    }

    public Object mutex() {
      return data;
    }

    public String toString() {
      return "mm" + str(data);
    }
  }

  static public interface Hasher<A> {

    public int hashCode(A a);

    public boolean equals(A a, A b);
  }

  static public interface IF2<A, B, C> {

    public C get(A a, B b);
  }

  static final public class WeakHasherMap<K, V> extends AbstractMap<K, V> implements Map<K, V> {

    public Hasher hasher = null;

    final public boolean keyEquals(Object k1, Object k2) {
      return (hasher == null ? k1.equals(k2) : hasher.equals(k1, k2));
    }

    final public int keyHashCode(Object k1) {
      return (hasher == null ? k1.hashCode() : hasher.hashCode(k1));
    }

    final public WeakKey WeakKeyCreate(K k) {
      if (k == null)
        return null;
      else
        return new WeakKey(k);
    }

    final public WeakKey WeakKeyCreate(K k, ReferenceQueue<? super K> q) {
      if (k == null)
        return null;
      else
        return new WeakKey(k, q);
    }

    final public class WeakKey extends WeakReference<K> {

      public int hash;

      public WeakKey(K k) {
        super(k);
        hash = keyHashCode(k);
      }

      final public WeakKey create(K k) {
        if (k == null)
          return null;
        else
          return new WeakKey(k);
      }

      public WeakKey(K k, ReferenceQueue<? super K> q) {
        super(k, q);
        hash = keyHashCode(k);
      }

      final public WeakKey create(K k, ReferenceQueue<? super K> q) {
        if (k == null)
          return null;
        else
          return new WeakKey(k, q);
      }

      @Override
      public boolean equals(Object o) {
        if (o == null)
          return false;
        if (this == o)
          return true;
        if (!(o.getClass().equals(WeakKey.class)))
          return false;
        Object t = this.get();
        @SuppressWarnings("unchecked")
        Object u = ((WeakKey) o).get();
        if ((t == null) || (u == null))
          return false;
        if (t == u)
          return true;
        return keyEquals(t, u);
      }

      @Override
      public int hashCode() {
        return hash;
      }
    }

    public HashMap<WeakKey, V> hash;

    public ReferenceQueue<? super K> queue = new ReferenceQueue<K>();

    @SuppressWarnings("unchecked")
    final public void processQueue() {
      WeakKey wk;
      while ((wk = (WeakKey) queue.poll()) != null) {
        hash.remove(wk);
      }
    }

    public WeakHasherMap(int initialCapacity, float loadFactor) {
      hash = new HashMap<WeakKey, V>(initialCapacity, loadFactor);
    }

    public WeakHasherMap(int initialCapacity) {
      hash = new HashMap<WeakKey, V>(initialCapacity);
    }

    public WeakHasherMap() {
      hash = new HashMap<WeakKey, V>();
    }

    public WeakHasherMap(Hasher h) {
      hash = new HashMap<WeakKey, V>();
      hasher = h;
    }

    @Override
    public int size() {
      return entrySet().size();
    }

    @Override
    public boolean isEmpty() {
      return entrySet().isEmpty();
    }

    @Override
    public boolean containsKey(Object key) {
      @SuppressWarnings("unchecked")
      K kkey = (K) key;
      return hash.containsKey(WeakKeyCreate(kkey));
    }

    @Override
    public V get(Object key) {
      @SuppressWarnings("unchecked")
      K kkey = (K) key;
      return hash.get(WeakKeyCreate(kkey));
    }

    @Override
    public V put(K key, V value) {
      processQueue();
      return hash.put(WeakKeyCreate(key, queue), value);
    }

    @Override
    public V remove(Object key) {
      processQueue();
      @SuppressWarnings("unchecked")
      K kkey = (K) key;
      return hash.remove(WeakKeyCreate(kkey));
    }

    @Override
    public void clear() {
      processQueue();
      hash.clear();
    }

    @SuppressWarnings("TypeParameterShadowing")
    final public class Entry<K, V> implements Map.Entry<K, V> {

      public Map.Entry<WeakKey, V> ent;

      public K key;

      public Entry(Map.Entry<WeakKey, V> ent, K key) {
        this.ent = ent;
        this.key = key;
      }

      @Override
      public K getKey() {
        return key;
      }

      @Override
      public V getValue() {
        return ent.getValue();
      }

      @Override
      public V setValue(V value) {
        return ent.setValue(value);
      }

      final public boolean keyvalEquals(K o1, K o2) {
        return (o1 == null) ? (o2 == null) : keyEquals(o1, o2);
      }

      final public boolean valEquals(V o1, V o2) {
        return (o1 == null) ? (o2 == null) : o1.equals(o2);
      }

      @SuppressWarnings("NonOverridingEquals")
      public boolean equals(Map.Entry<K, V> e) {
        return (keyvalEquals(key, e.getKey()) && valEquals(getValue(), e.getValue()));
      }

      @Override
      public int hashCode() {
        V v;
        return (((key == null) ? 0 : keyHashCode(key)) ^ (((v = getValue()) == null) ? 0 : v.hashCode()));
      }
    }

    final public class EntrySet extends AbstractSet<Map.Entry<K, V>> {

      public Set<Map.Entry<WeakKey, V>> hashEntrySet = hash.entrySet();

      @Override
      public Iterator<Map.Entry<K, V>> iterator() {
        return new Iterator<Map.Entry<K, V>>() {

          public Iterator<Map.Entry<WeakKey, V>> hashIterator = hashEntrySet.iterator();

          public Map.Entry<K, V> next = null;

          @Override
          public boolean hasNext() {
            while (hashIterator.hasNext()) {
              Map.Entry<WeakKey, V> ent = hashIterator.next();
              WeakKey wk = ent.getKey();
              K k = null;
              if ((wk != null) && ((k = wk.get()) == null)) {
                continue;
              }
              next = new Entry<K, V>(ent, k);
              return true;
            }
            return false;
          }

          @Override
          public Map.Entry<K, V> next() {
            if ((next == null) && !hasNext())
              throw new NoSuchElementException();
            Map.Entry<K, V> e = next;
            next = null;
            return e;
          }

          @Override
          public void remove() {
            hashIterator.remove();
          }
        };
      }

      @Override
      public boolean isEmpty() {
        return !(iterator().hasNext());
      }

      @Override
      public int size() {
        int j = 0;
        for (Iterator<Map.Entry<K, V>> i = iterator(); i.hasNext(); i.next()) j++;
        return j;
      }

      @Override
      public boolean remove(Object o) {
        processQueue();
        if (!(o instanceof Map.Entry<?, ?>))
          return false;
        @SuppressWarnings("unchecked")
        Map.Entry<K, V> e = (Map.Entry<K, V>) o;
        Object ev = e.getValue();
        WeakKey wk = WeakKeyCreate(e.getKey());
        Object hv = hash.get(wk);
        if ((hv == null) ? ((ev == null) && hash.containsKey(wk)) : hv.equals(ev)) {
          hash.remove(wk);
          return true;
        }
        return false;
      }

      @Override
      public int hashCode() {
        int h = 0;
        for (Iterator<Map.Entry<WeakKey, V>> i = hashEntrySet.iterator(); i.hasNext(); ) {
          Map.Entry<WeakKey, V> ent = i.next();
          WeakKey wk = ent.getKey();
          Object v;
          if (wk == null)
            continue;
          h += (wk.hashCode() ^ (((v = ent.getValue()) == null) ? 0 : v.hashCode()));
        }
        return h;
      }
    }

    public Set<Map.Entry<K, V>> entrySet = null;

    @Override
    public Set<Map.Entry<K, V>> entrySet() {
      if (entrySet == null)
        entrySet = new EntrySet();
      return entrySet;
    }

    public K findKey(Object key) {
      processQueue();
      K kkey = (K) key;
      WeakKey wkey = WeakKeyCreate(kkey);
      WeakKey found = hashMap_findKey(hash, wkey);
      return found == null ? null : found.get();
    }
  }

  static public class TestFunctionValues<A, B> implements IFieldsToList {

    public IF1<A, B> function;

    public TestFunctionValues() {
    }

    public TestFunctionValues(IF1<A, B> function) {
      this.function = function;
    }

    public String toString() {
      return shortClassName_dropNumberPrefix(this) + "(" + function + ")";
    }

    public boolean equals(Object o) {
      if (!(o instanceof TestFunctionValues))
        return false;
      TestFunctionValues __1 = (TestFunctionValues) o;
      return eq(function, __1.function);
    }

    public int hashCode() {
      int h = -447340436;
      h = boostHashCombine(h, _hashCode(function));
      return h;
    }

    public Object[] _fieldsToList() {
      return new Object[] { function };
    }

    public List<Pair<A, B>> pairs = new ArrayList();

    public TestFunctionValues<A, B> io(A input, B output) {
      pairs.add(pair(input, output));
      return this;
    }

    public void clear() {
      pairs.clear();
    }

    public void run() {
      try {
        for (var p : pairs) testFunctionValue(function, p.a, p.b);
        print(nTests(pairs) + " OK");
      } catch (Exception __e) {
        throw rethrow(__e);
      }
    }

    public void runAndClear() {
      run();
      clear();
    }
  }

  static public interface IIntPred {

    public boolean get(int a);
  }

  static public class Pair<A, B> implements Comparable<Pair<A, B>> {

    final public Pair<A, B> setA(A a) {
      return a(a);
    }

    public Pair<A, B> a(A a) {
      this.a = a;
      return this;
    }

    final public A getA() {
      return a();
    }

    public A a() {
      return a;
    }

    public A a;

    final public Pair<A, B> setB(B b) {
      return b(b);
    }

    public Pair<A, B> b(B b) {
      this.b = b;
      return this;
    }

    final public B getB() {
      return b();
    }

    public B b() {
      return b;
    }

    public B b;

    public Pair() {
    }

    public Pair(A a, B b) {
      this.b = b;
      this.a = a;
    }

    public int hashCode() {
      return hashCodeFor(a) + 2 * hashCodeFor(b);
    }

    public boolean equals(Object o) {
      if (o == this)
        return true;
      if (!(o instanceof Pair))
        return false;
      Pair t = (Pair) o;
      return eq(a, t.a) && eq(b, t.b);
    }

    public String toString() {
      return "<" + a + ", " + b + ">";
    }

    public int compareTo(Pair<A, B> p) {
      if (p == null)
        return 1;
      int i = ((Comparable<A>) a).compareTo(p.a);
      if (i != 0)
        return i;
      return ((Comparable<B>) b).compareTo(p.b);
    }
  }

  static public class Fail extends RuntimeException implements IFieldsToList {

    public Object[] objects;

    public Fail() {
    }

    public Fail(Object... objects) {
      this.objects = objects;
    }

    public Object[] _fieldsToList() {
      return new Object[] { objects };
    }

    public Fail(Throwable cause, Object... objects) {
      super(cause);
      this.objects = objects;
    }

    public String toString() {
      return joinNemptiesWithColon("Fail", commaCombine(getCause(), objects));
    }
  }

  static public class LASValueDescriptor {

    public LASValueDescriptor() {
    }

    public boolean knownValue() {
      return false;
    }

    public Object value() {
      return null;
    }

    public Class javaClass() {
      return null;
    }

    public boolean javaClassIsExact() {
      return false;
    }

    public boolean canBeNull() {
      return true;
    }

    public boolean canFail() {
      return false;
    }

    public boolean willFail() {
      return false;
    }

    static public class Exact extends LASValueDescriptor implements IFieldsToList {

      public Class c;

      public boolean canBeNull = false;

      public Exact() {
      }

      public Exact(Class c, boolean canBeNull) {
        this.canBeNull = canBeNull;
        this.c = c;
      }

      public String toString() {
        return shortClassName_dropNumberPrefix(this) + "(" + c + ", " + canBeNull + ")";
      }

      public boolean equals(Object o) {
        if (!(o instanceof Exact))
          return false;
        Exact __1 = (Exact) o;
        return eq(c, __1.c) && eq(canBeNull, __1.canBeNull);
      }

      public int hashCode() {
        int h = 67394271;
        h = boostHashCombine(h, _hashCode(c));
        h = boostHashCombine(h, _hashCode(canBeNull));
        return h;
      }

      public Object[] _fieldsToList() {
        return new Object[] { c, canBeNull };
      }

      public Class javaClass() {
        return c;
      }

      public boolean javaClassIsExact() {
        return true;
      }

      public boolean canBeNull() {
        return canBeNull;
      }
    }

    static public class NonExact extends LASValueDescriptor implements IFieldsToList {

      public Class c;

      public boolean canBeNull = false;

      public NonExact() {
      }

      public NonExact(Class c, boolean canBeNull) {
        this.canBeNull = canBeNull;
        this.c = c;
      }

      public String toString() {
        return shortClassName_dropNumberPrefix(this) + "(" + c + ", " + canBeNull + ")";
      }

      public boolean equals(Object o) {
        if (!(o instanceof NonExact))
          return false;
        NonExact __2 = (NonExact) o;
        return eq(c, __2.c) && eq(canBeNull, __2.canBeNull);
      }

      public int hashCode() {
        int h = 1445514322;
        h = boostHashCombine(h, _hashCode(c));
        h = boostHashCombine(h, _hashCode(canBeNull));
        return h;
      }

      public Object[] _fieldsToList() {
        return new Object[] { c, canBeNull };
      }

      public Class javaClass() {
        return c;
      }

      public boolean javaClassIsExact() {
        return false;
      }

      public boolean canBeNull() {
        return canBeNull;
      }
    }

    static public class KnownValue extends LASValueDescriptor implements IFieldsToList {

      public Object value;

      public KnownValue() {
      }

      public KnownValue(Object value) {
        this.value = value;
      }

      public String toString() {
        return shortClassName_dropNumberPrefix(this) + "(" + value + ")";
      }

      public boolean equals(Object o) {
        if (!(o instanceof KnownValue))
          return false;
        KnownValue __3 = (KnownValue) o;
        return eq(value, __3.value);
      }

      public int hashCode() {
        int h = -1456305138;
        h = boostHashCombine(h, _hashCode(value));
        return h;
      }

      public Object[] _fieldsToList() {
        return new Object[] { value };
      }

      public boolean knownValue() {
        return true;
      }

      public Object value() {
        return value;
      }

      public Class javaClass() {
        return value == null ? null : value.getClass();
      }

      public boolean javaClassIsExact() {
        return value != null;
      }

      public boolean canBeNull() {
        return value == null;
      }
    }

    static public class WillFail extends LASValueDescriptor {

      public boolean canFail() {
        return true;
      }

      public boolean willFail() {
        return true;
      }
    }

    static public LASValueDescriptor fromClass(Class c) {
      return new NonExact(c, true);
    }
  }

  static public class PingSourceCancelledException extends RuntimeException implements IFieldsToList {

    public PingSource pingSource;

    public PingSourceCancelledException() {
    }

    public PingSourceCancelledException(PingSource pingSource) {
      this.pingSource = pingSource;
    }

    public String toString() {
      return shortClassName_dropNumberPrefix(this) + "(" + pingSource + ")";
    }

    public Object[] _fieldsToList() {
      return new Object[] { pingSource };
    }
  }

  static public class TokenRangeWithSrc extends TokenRange {

    public List<String> tok;

    public TokenRangeWithSrc() {
    }

    public TokenRangeWithSrc(List<String> tok, int start) {
      this.start = start;
      end = start;
    }

    public TokenRangeWithSrc(List<String> tok, int start, int end) {
      this.end = end;
      this.start = start;
    }

    public TokenRangeWithSrc(ListAndIndex<String> startPtr, ListAndIndex<String> endPtr) {
      assertNotNull("startPtr", startPtr);
      assertNotNull("endPtr", endPtr);
      assertSame(tok = startPtr.list(), endPtr.list());
      start = startPtr.idx();
      end = endPtr.idx();
    }

    public ListAndIndex<String> startPtr() {
      return new ListAndIndex(tok, start);
    }

    public ListAndIndex<String> endPtr() {
      return new ListAndIndex(tok, end);
    }

    public LineAndColumn startLineAndCol() {
      return tokenToLineAndColumn(startPtr());
    }

    public LineAndColumn endLineAndCol() {
      return tokenToLineAndColumn(endPtr());
    }

    public String text() {
      return joinSubList(tok, start, end);
    }

    public String toString() {
      var start = startLineAndCol();
      if (eq(start, end))
        return str(start);
      return start + " to " + endLineAndCol();
    }

    public String fullSourceText() {
      return join(tok);
    }
  }

  static public class ResolvableLASClass implements IFieldsToList {

    static final public String _fieldOrder = "lasClassLoader classDef resolvedClass";

    public LASClassLoader lasClassLoader;

    public LASClassDef classDef;

    public ResolvableLASClass() {
    }

    public ResolvableLASClass(LASClassLoader lasClassLoader, LASClassDef classDef) {
      this.classDef = classDef;
      this.lasClassLoader = lasClassLoader;
    }

    public boolean equals(Object o) {
      if (!(o instanceof ResolvableLASClass))
        return false;
      ResolvableLASClass __2 = (ResolvableLASClass) o;
      return eq(lasClassLoader, __2.lasClassLoader) && eq(classDef, __2.classDef);
    }

    public int hashCode() {
      int h = -1660305875;
      h = boostHashCombine(h, _hashCode(lasClassLoader));
      h = boostHashCombine(h, _hashCode(classDef));
      return h;
    }

    public Object[] _fieldsToList() {
      return new Object[] { lasClassLoader, classDef };
    }

    public Class resolvedClass;

    public Class get() {
      if (resolvedClass == null) {
        if (lasClassLoader == null)
          throw fail("Need LASClassLoader to define " + classDef.userGivenName);
        resolvedClass = lasClassLoader.defineLASClass(classDef.finalClassName(), () -> classDef.toBytes());
        classDef.init(resolvedClass);
      }
      return resolvedClass;
    }

    public String toString() {
      if (resolvedClass != null)
        return className(resolvedClass);
      {
        var __1 = classDef.userGivenName;
        if (__1 != null)
          return __1;
      }
      if (classDef.classHash_cache != null)
        return classDef.finalClassNameWithoutPrefix();
      return or2(classDef.userGivenName, "script-defined class") + " [unresolved]";
    }
  }

  static public class InMemoryClassLoader extends ClassLoader {

    final public InMemoryClassLoader setRememberClassBytes(boolean rememberClassBytes) {
      return rememberClassBytes(rememberClassBytes);
    }

    public InMemoryClassLoader rememberClassBytes(boolean rememberClassBytes) {
      this.rememberClassBytes = rememberClassBytes;
      return this;
    }

    final public boolean getRememberClassBytes() {
      return rememberClassBytes();
    }

    public boolean rememberClassBytes() {
      return rememberClassBytes;
    }

    transient public boolean rememberClassBytes = false;

    transient public Map<Class, byte[]> classBytes = syncMap();

    public InMemoryClassLoader(ClassLoader parent) {
      super(parent);
    }

    public Class<?> defineAClass(String name, byte[] bytes) {
      Class c = defineClass(name, bytes, 0, bytes.length);
      if (rememberClassBytes)
        classBytes.put(c, bytes);
      return c;
    }

    public byte[] getClassBytes(Class c) {
      return classBytes.get(c);
    }
  }

  static public class ThreadPool implements AutoCloseable {

    public int max = numberOfCores();

    public List<PooledThread> all = new ArrayList();

    public Set<PooledThread> used = new HashSet();

    public Set<PooledThread> free = new HashSet();

    public boolean verbose, retired;

    public class InternalPingSource extends PingSource {
    }

    public InternalPingSource internalPingSource = new InternalPingSource();

    public MultiSleeper sleeper = new MultiSleeper();

    public ThreadPool() {
    }

    public ThreadPool(int max) {
      this.max = max;
    }

    synchronized public int maxSize() {
      return max;
    }

    synchronized public int total() {
      return l(used) + l(free);
    }

    transient public Set<Runnable> onCustomerMustWaitAlert;

    public ThreadPool onCustomerMustWaitAlert(Runnable r) {
      onCustomerMustWaitAlert = createOrAddToSyncLinkedHashSet(onCustomerMustWaitAlert, r);
      return this;
    }

    public ThreadPool removeCustomerMustWaitAlertListener(Runnable r) {
      main.remove(onCustomerMustWaitAlert, r);
      return this;
    }

    public void customerMustWaitAlert() {
      if (onCustomerMustWaitAlert != null)
        for (var listener : onCustomerMustWaitAlert) pcallF_typed(listener);
    }

    public void fireCustomerMustWaitAlert() {
      vmBus_send("customerMustWaitAlert", this, currentThread());
      customerMustWaitAlert();
    }

    public PooledThread acquireThreadOrQueue(Runnable action) {
      if (action == null)
        return null;
      PooledThread t;
      synchronized (this) {
        if (_hasFreeAfterCreating()) {
          t = _firstFreeThread();
          markUsed(t);
        } else
          t = _anyThread();
      }
      t.addWork(action);
      return t;
    }

    public boolean _hasFreeAfterCreating() {
      checkNotRetired();
      if (nempty(free))
        return true;
      if (total() < max) {
        PooledThread t = newThread();
        all.add(t);
        free.add(t);
        return true;
      }
      return false;
    }

    public PooledThread acquireThreadOrWait(Runnable action) {
      try {
        if (action == null)
          return null;
        PooledThread t;
        while (true) {
          synchronized (this) {
            if (_hasFreeAfterCreating()) {
              t = _firstFreeThread();
              break;
            } else
              _waitWaitWait();
          }
        }
        t.addWork(action);
        return t;
      } catch (Exception __e) {
        throw rethrow(__e);
      }
    }

    public PooledThread _firstFreeThread() {
      return first(free);
    }

    public PooledThread _anyThread() {
      return random(used);
    }

    public class PooledThread extends Thread {

      public PooledThread(String name) {
        super(name);
      }

      public AppendableChain<Runnable> q;

      synchronized public Runnable _grabWorkOrSleep() {
        try {
          Runnable r = first(q);
          if (r == null) {
            markFree(this);
            if (verbose)
              print("Thread sleeps");
            synchronized (this) {
              wait();
            }
            if (verbose)
              print("Thread woke up");
            return null;
          }
          q = popFirst(q);
          return r;
        } catch (Exception __e) {
          throw rethrow(__e);
        }
      }

      public void run() {
        try {
          pingSource_tl().set(internalPingSource);
          while (!retired()) {
            ping();
            Runnable r = _grabWorkOrSleep();
            if (verbose)
              print(this + " work: " + r);
            if (r != null)
              try {
                if (verbose)
                  print(this + " running: " + r);
                r.run();
                pingSource_tl().set(internalPingSource);
                if (verbose)
                  print(this + " done");
              } catch (Throwable e) {
                pingSource_tl().set(internalPingSource);
                if (verbose)
                  print(this + " error");
                printStackTrace(e);
              } finally {
                pingSource_tl().set(internalPingSource);
                if (verbose)
                  print("ThreadPool finally");
              }
          }
        } catch (Exception __e) {
          throw rethrow(__e);
        }
      }

      synchronized public boolean isEmpty() {
        return empty(q);
      }

      public void addWork(Runnable r) {
        if (verbose)
          print("Added work to " + this + ": " + r);
        synchronized (this) {
          q = chainPlus(q, r);
          notifyAll();
        }
      }
    }

    public PooledThread newThread() {
      PooledThread t = new PooledThread("Thread Pool Inhabitant " + n2(total() + 1));
      t.start();
      return t;
    }

    synchronized public void markFree(PooledThread t) {
      used.remove(t);
      free.add(t);
      notifyAll();
    }

    synchronized public void markUsed(PooledThread t) {
      free.remove(t);
      used.add(t);
    }

    synchronized public String toString() {
      return retired() ? "Retired ThreadPool" : "ThreadPool " + roundBracket(commaCombine(n2(used) + " used out of " + n2(total()), max <= total() ? null : "could grow to " + n2(max)));
    }

    synchronized public boolean retired() {
      return retired;
    }

    synchronized public void retire() {
      if (verbose)
        print("ThreadPool Retiring");
      retired = true;
      for (var thread : free) syncNotifyAll(thread);
    }

    public void checkNotRetired() {
      if (retired())
        throw fail("retired");
    }

    synchronized public void close() {
      try {
        retire();
      } catch (Exception __e) {
        throw rethrow(__e);
      }
    }

    public void _waitWaitWait() {
      try {
        do {
          fireCustomerMustWaitAlert();
          wait();
          checkNotRetired();
        } while (empty(free));
      } catch (Exception __e) {
        throw rethrow(__e);
      }
    }

    public void dO(String text, Runnable r) {
      if (r == null)
        return;
      new PingSource(this, text).dO(r);
    }

    public ISleeper_v2 sleeper() {
      return sleeper;
    }
  }

  static public interface IAutoCloseableF0<A> extends IF0<A>, AutoCloseable {
  }

  static public class G22Utils_Base {

    transient public Set<IVF1<File>> onProjectFileChanged;

    public G22Utils_Base onProjectFileChanged(IVF1<File> f) {
      onProjectFileChanged = createOrAddToSyncLinkedHashSet(onProjectFileChanged, f);
      return this;
    }

    public G22Utils_Base removeProjectFileChangedListener(IVF1<File> f) {
      main.remove(onProjectFileChanged, f);
      return this;
    }

    public void projectFileChanged(File file) {
      if (onProjectFileChanged != null)
        for (var listener : onProjectFileChanged) pcallF_typed(listener, file);
    }
  }

  static public class G22Utils extends G22Utils_Base implements AutoCloseable {

    final public G22Utils setBackgroundProcessesUI(IBackgroundProcesses backgroundProcessesUI) {
      return backgroundProcessesUI(backgroundProcessesUI);
    }

    public G22Utils backgroundProcessesUI(IBackgroundProcesses backgroundProcessesUI) {
      this.backgroundProcessesUI = backgroundProcessesUI;
      return this;
    }

    final public IBackgroundProcesses getBackgroundProcessesUI() {
      return backgroundProcessesUI();
    }

    public IBackgroundProcesses backgroundProcessesUI() {
      return backgroundProcessesUI;
    }

    public IBackgroundProcesses backgroundProcessesUI;

    final public G22Utils setModule(Enterable module) {
      return module(module);
    }

    public G22Utils module(Enterable module) {
      this.module = module;
      return this;
    }

    final public Enterable getModule() {
      return module();
    }

    public Enterable module() {
      return module;
    }

    public Enterable module;

    final public G22Utils setMasterStuff(G22MasterStuff masterStuff) {
      return masterStuff(masterStuff);
    }

    public G22Utils masterStuff(G22MasterStuff masterStuff) {
      this.masterStuff = masterStuff;
      return this;
    }

    final public G22MasterStuff getMasterStuff() {
      return masterStuff();
    }

    public G22MasterStuff masterStuff() {
      return masterStuff;
    }

    public G22MasterStuff masterStuff;

    final public G22Utils setConcepts(Concepts concepts) {
      return concepts(concepts);
    }

    public G22Utils concepts(Concepts concepts) {
      this.concepts = concepts;
      return this;
    }

    final public Concepts getConcepts() {
      return concepts();
    }

    public Concepts concepts() {
      return concepts;
    }

    public Concepts concepts;

    final public G22Utils setProjectActions(G22ProjectActions projectActions) {
      return projectActions(projectActions);
    }

    public G22Utils projectActions(G22ProjectActions projectActions) {
      this.projectActions = projectActions;
      return this;
    }

    final public G22ProjectActions getProjectActions() {
      return projectActions();
    }

    public G22ProjectActions projectActions() {
      return projectActions;
    }

    public G22ProjectActions projectActions;

    final public G22AutoStarter getAutoStarter() {
      return autoStarter();
    }

    public G22AutoStarter autoStarter() {
      return autoStarter;
    }

    public G22AutoStarter autoStarter = new G22AutoStarter(this);

    final public G22Utils setFunctionTimings(FunctionTimings<String> functionTimings) {
      return functionTimings(functionTimings);
    }

    public G22Utils functionTimings(FunctionTimings<String> functionTimings) {
      this.functionTimings = functionTimings;
      return this;
    }

    final public FunctionTimings<String> getFunctionTimings() {
      return functionTimings();
    }

    public FunctionTimings<String> functionTimings() {
      return functionTimings;
    }

    public FunctionTimings<String> functionTimings = new FunctionTimings();

    public FileWatchService fileWatcher;

    public boolean projectFileListenerInitiated = false;

    final public CombinedStringifier getStringifier() {
      return stringifier();
    }

    public CombinedStringifier stringifier() {
      return stringifier;
    }

    public CombinedStringifier stringifier = new CombinedStringifier(o -> o instanceof BufferedImage ? "Image (" + ((BufferedImage) o).getWidth() + "*" + ((BufferedImage) o).getHeight() + " px)" : null);

    public LASClassLoader lasClassLoader() {
      return masterStuff == null ? null : masterStuff.lasClassLoader();
    }

    public ImageSurface stdImageSurface() {
      var is = pixelatedImageSurface().setAutoZoomToDisplay(true).repaintInThread(false);
      is.defaultImageDir = () -> dbDir();
      is.specialPurposed = true;
      new ImageSurface_PositionToolTip(is);
      return is;
    }

    public ImageSurface stdImageSurface(MakesBufferedImage img) {
      return stdImageSurface(toBufferedImage(img));
    }

    public ImageSurface stdImageSurface(BufferedImage img) {
      var is = stdImageSurface();
      is.setImage(img);
      return is;
    }

    public ImageSurface stdImageSurfaceWithSelection(MakesBufferedImage img, Rect selection) {
      return stdImageSurfaceWithSelection(toBufferedImage(img), selection);
    }

    public ImageSurface stdImageSurfaceWithSelection(BufferedImage img, Rect selection) {
      var is = stdImageSurface(img);
      is.setSelection(selection);
      return is;
    }

    public String stringify(Object o) {
      return stringifier.toString(o);
    }

    transient public Set<IVF1<GazelleV_LeftArrowScriptParser>> onSettingUpParser;

    public G22Utils onSettingUpParser(IVF1<GazelleV_LeftArrowScriptParser> f) {
      onSettingUpParser = createOrAddToSyncLinkedHashSet(onSettingUpParser, f);
      return this;
    }

    public G22Utils removeSettingUpParserListener(IVF1<GazelleV_LeftArrowScriptParser> f) {
      main.remove(onSettingUpParser, f);
      return this;
    }

    public void settingUpParser(GazelleV_LeftArrowScriptParser parser) {
      if (onSettingUpParser != null)
        for (var listener : onSettingUpParser) pcallF_typed(listener, parser);
    }

    transient public Set<IVF1<JLeftArrowScriptIDE>> onSettingUpScriptIDE;

    public G22Utils onSettingUpScriptIDE(IVF1<JLeftArrowScriptIDE> f) {
      onSettingUpScriptIDE = createOrAddToSyncLinkedHashSet(onSettingUpScriptIDE, f);
      return this;
    }

    public G22Utils removeSettingUpScriptIDEListener(IVF1<JLeftArrowScriptIDE> f) {
      main.remove(onSettingUpScriptIDE, f);
      return this;
    }

    public void settingUpScriptIDE(JLeftArrowScriptIDE ide) {
      if (onSettingUpScriptIDE != null)
        for (var listener : onSettingUpScriptIDE) pcallF_typed(listener, ide);
    }

    public GazelleV_LeftArrowScriptParser leftArrowParser() {
      GazelleV_LeftArrowScriptParser parser = new GazelleV_LeftArrowScriptParser();
      parser.g22utils(this);
      parser.lasClassLoader(lasClassLoader());
      settingUpParser(parser);
      return parser;
    }

    public void basicParserTest() {
      var parser = leftArrowParser();
      print("classContainerPrefixes", parser.classContainerPrefixes());
      assertEquals(pair(1, 2), parser.parse("new Pair 1 2").get());
    }

    public JLeftArrowScriptIDE leftArrowIDE() {
      JLeftArrowScriptIDE ide = new JLeftArrowScriptIDE();
      ide.g22utils(this);
      ide.scriptTimeout(projectWideScriptTimeout());
      settingUpScriptIDE(ide);
      return ide;
    }

    public File byteCodePath() {
      return assertNotNull(getBytecodePathForClass(this));
    }

    public ClassNameResolver classNameResolver_cache;

    public ClassNameResolver classNameResolver() {
      if (classNameResolver_cache == null)
        classNameResolver_cache = classNameResolver_load();
      return classNameResolver_cache;
    }

    public ClassNameResolver classNameResolver_load() {
      return new ClassNameResolver().byteCodePath(byteCodePath()).init();
    }

    public File databasesMotherDir() {
      return javaxDataDir("Gazelle-22");
    }

    public AutoCloseable enter() {
      return module == null ? null : module.enter();
    }

    public String defaultDBName() {
      return "Default";
    }

    public File lastOpenedDBsFile() {
      return newFile(databasesMotherDir(), "Last Opened");
    }

    public File autoUpdateFile() {
      return newFile(databasesMotherDir(), "Auto-Update");
    }

    public boolean autoUpdateEnabled() {
      return fileExists(autoUpdateFile());
    }

    public void setAutoUpdate(boolean b) {
      createOrRemoveFile(autoUpdateFile(), b);
    }

    public List<String> dbsToOpen() {
      List<String> dbNames = new ArrayList();
      for (String name : tlft(loadTextFile(lastOpenedDBsFile()))) if (fileExists(newFile(databasesMotherDir(), name)))
        dbNames.add(name);
      if (empty(dbNames))
        dbNames.add(defaultDBName());
      return dbNames;
    }

    public void setOpenDBs(Collection<File> dbDirs) {
      List<String> dbNames = new ArrayList();
      for (File dbDir : dbDirs) if (sameFile(databasesMotherDir(), dirOfFile(dbDir)))
        dbNames.add(fileName(dbDir));
      saveTextFile(lastOpenedDBsFile(), lines(dbNames));
    }

    public Map<String, Object> scriptToMap(G22LeftArrowScript c) {
      return scriptToMap(c, false);
    }

    public Map<String, Object> scriptToMap(G22LeftArrowScript c, boolean allowRunOnProjectOpen) {
      return litorderedmap("Description", str(c), "Status", renderScriptStatus(c), "LoC", renderScriptLoC(c), "Run on project open", c.renderRunOnProjectOpenStatus());
    }

    public String renderScriptStatus(G22LeftArrowScript c) {
      return or2_rev("Empty", joinNemptiesWithSpacedPlus(c.isClearForAutoRun() ? "Clear for auto-run" : null, c.isSavedDistinctFromAutoRunVersion() ? "Saved (not cleared)" : null, c.isEditing() ? "Editing" : null));
    }

    public String renderScriptLoC(G22LeftArrowScript c) {
      return n2(intMax(mapLL(__68 -> linesOfCode_javaTok(__68), c.editingText, c.text, c.codeForAutoRun())));
    }

    public List<G22Label> labelsForFile(File file) {
      if (file == null)
        return null;
      File labelsFile = appendToFileName(file, ".labels");
      List<String> labels = tlft(loadTextFile(labelsFile));
      return map(__69 -> getLabel(__69), labels);
    }

    public File labelsFile(File file) {
      if (file == null)
        return null;
      return appendToFileName(file, ".labels");
    }

    public void setLabelsForFile(File file, List<G22Label> labels) {
      List<String> list = map(labels, label -> label.name);
      File f = labelsFile(file);
      saveTextFile(f, lines(list));
      print("Saved " + nLabels(list) + " (" + joinWithComma(list) + ") to " + f);
    }

    public G22Label getLabel(String name) {
      if (empty(name))
        return null;
      if (containsNewLine(name))
        throw fail("No newlines in label names allowed: " + name);
      return uniqCI(concepts, G22Label.class, "name", name);
    }

    final public File projectDir() {
      return dbDir();
    }

    public File dbDir() {
      return conceptsDir(concepts);
    }

    public File fileInDbDir(String name) {
      return newFile(dbDir(), name);
    }

    public class GazelleDB implements IFieldsToList {

      public String name;

      public File dir;

      public GazelleDB() {
      }

      public GazelleDB(String name, File dir) {
        this.dir = dir;
        this.name = name;
      }

      public String toString() {
        return shortClassName_dropNumberPrefix(this) + "(" + name + ", " + dir + ")";
      }

      public boolean equals(Object o) {
        if (!(o instanceof GazelleDB))
          return false;
        GazelleDB __0 = (GazelleDB) o;
        return eq(name, __0.name) && eq(dir, __0.dir);
      }

      public int hashCode() {
        int h = 1669530526;
        h = boostHashCombine(h, _hashCode(name));
        h = boostHashCombine(h, _hashCode(dir));
        return h;
      }

      public Object[] _fieldsToList() {
        return new Object[] { name, dir };
      }

      public String name() {
        return name;
      }

      public File dir() {
        return dir;
      }

      public Boolean loaded_cache;

      public boolean loaded() {
        if (loaded_cache == null)
          loaded_cache = loaded_load();
        return loaded_cache;
      }

      public Boolean loaded_load() {
        return containsFile(masterStuff.openConceptDirs(), dir);
      }

      public File conceptsFile() {
        return conceptsFileIn(dir);
      }
    }

    public List<GazelleDB> gazelleDBs() {
      List<GazelleDB> dbs = new ArrayList();
      for (File dir : listDirsContainingFileNamed(databasesMotherDir(), "concepts.structure.gz")) dbs.add(new GazelleDB(fileName(dir), dir));
      return dbs;
    }

    public RSyntaxTextAreaWithSearch newSyntaxTextArea() {
      return newSyntaxTextArea((IF1) null);
    }

    public RSyntaxTextAreaWithSearch newSyntaxTextArea(IF1<JComponent, JComponent> wrapStatusLabel) {
      RSyntaxTextAreaWithSearch ta = new RSyntaxTextAreaWithSearch(wrapStatusLabel);
      ta.textArea().setHighlightCurrentLine(false);
      ta.menuLessOperation();
      return ta;
    }

    public RSyntaxTextAreaWithSearch newSyntaxTextArea(String text) {
      var ta = newSyntaxTextArea();
      ta.setText(text);
      return ta;
    }

    public File projectStoryTextFile() {
      return newFile(dbDir(), "story.txt");
    }

    public String projectName() {
      return fileName(dbDir());
    }

    public void close() {
      try {
        autoStarter.close();
        {
          cleanUp(fileWatcher);
          fileWatcher = null;
        }
      } catch (Exception __e) {
        throw rethrow(__e);
      }
    }

    public Object getProjectVar(String name) {
      G22Variable var = conceptWhere(concepts, G22Variable.class, "name", name);
      return var == null ? null : var.value;
    }

    public Object waitForProjectVar(String name) {
      G22Variable var = optimizedUniq(concepts, G22Variable.class, "name", name);
      Object o = var.value;
      {
        var __2 = o;
        if (__2 != null)
          return __2;
      }
      return waitUntilNotNull(var.varValue());
    }

    public void setProjectVar(boolean persistent, String name, Object value) {
      G22Variable var = optimizedUniq(concepts, G22Variable.class, "name", name);
      if (!persistent)
        var.persistent(persistent);
      var.value(value);
      if (persistent)
        var.persistent(persistent);
    }

    public void setTransientProjectVar(String name, Object value) {
      G22Variable var = optimizedUniq(concepts, G22Variable.class, "name", name);
      var.persistent(false).value(value);
    }

    public IVarWithNotify liveProjectVar(String name) {
      return liveProjectVar(name, null);
    }

    public IVarWithNotify liveProjectVar(String name, Object defaultValue) {
      G22Variable var = optimizedUniq(concepts, G22Variable.class, "name", name);
      var.persistent(true);
      var.setValueIfNull(defaultValue);
      return var.varValue();
    }

    public IVarWithNotify liveTransientProjectVar(String name) {
      return liveTransientProjectVar(name, null);
    }

    public IVarWithNotify liveTransientProjectVar(String name, Object defaultValue) {
      G22Variable var = optimizedUniq(concepts, G22Variable.class, "name", name);
      var.persistent(false);
      var.setValueIfNull(defaultValue);
      return var.varValue();
    }

    public double defaultScriptTimeout() {
      return 10.0;
    }

    public double projectWideScriptTimeout() {
      return or(toDoubleOrNull(getProjectVar("!Script Timeout")), defaultScriptTimeout());
    }

    public G22Analyzer getAnalyzer(long id) {
      var a = getConcept(concepts, G22Analyzer.class, id);
      if (a == null)
        throw fail("Analyzer not found: " + id);
      return a;
    }

    public G22LeftArrowScript getScript(long id) {
      var a = getConcept(concepts, G22LeftArrowScript.class, id);
      if (a == null)
        throw fail("Script not found: " + id);
      return a;
    }

    public Object callScript(long id) {
      var script = getScript(id);
      return script.evaluateWithoutTimeout();
    }

    public Object callAutoRunnableScript(long id) {
      var script = getScript(id);
      return script.evaluateAutoRunWithoutTimeout();
    }

    public double defaultTimeout() {
      return infinity();
    }

    public <A> A evalRegisteredCode(String processName, IF0<A> code) {
      return evalRegisteredCode(defaultTimeout(), processName, code);
    }

    public <A> A evalRegisteredCode(double timeoutSeconds, String processName, IF0<A> code) {
      if (code == null)
        return null;
      return evalWithTimeoutOrTypedException(timeoutSeconds, () -> {
        AutoCloseable __3 = enter();
        try {
          var process = backgroundProcessesUI.tempAdd(processName);
          try {
            Thread myThread = currentThread();
            process.setInterruptAction(new Runnable() {

              public void run() {
                try {
                  cancelThread(myThread);
                } catch (Exception __e) {
                  throw rethrow(__e);
                }
              }

              public String toString() {
                return "cancelThread(myThread)";
              }
            });
            return code.get();
          } finally {
            _close(process);
          }
        } finally {
          _close(__3);
        }
      });
    }

    public Object host() {
      AutoCloseable __4 = enter();
      try {
        return dm_os();
      } finally {
        _close(__4);
      }
    }

    public <A> A timeFunction(String name, IF0<A> f) {
      return functionTimings.get(name, f);
    }

    public boolean isConceptsDir(File dir) {
      return isSameFile(conceptsDir(concepts), dir);
    }

    synchronized public FileWatchService fileWatcher() {
      {
        if (fileWatcher == null)
          fileWatcher = new FileWatchService();
        return fileWatcher;
      }
    }

    synchronized public G22Utils onProjectFileChanged(IVF1<File> listener) {
      super.onProjectFileChanged(listener);
      if (!projectFileListenerInitiated) {
        projectFileListenerInitiated = true;
        fileWatcher().addRecursiveListener(dbDir(), __5 -> projectFileChanged(__5));
      }
      return this;
    }
  }

  static public class LASClassDef {

    final public LASClassDef setUserGivenName(String userGivenName) {
      return userGivenName(userGivenName);
    }

    public LASClassDef userGivenName(String userGivenName) {
      this.userGivenName = userGivenName;
      return this;
    }

    final public String getUserGivenName() {
      return userGivenName();
    }

    public String userGivenName() {
      return userGivenName;
    }

    public String userGivenName;

    final public LASClassDef setClassDefPrefix(String classDefPrefix) {
      return classDefPrefix(classDefPrefix);
    }

    public LASClassDef classDefPrefix(String classDefPrefix) {
      this.classDefPrefix = classDefPrefix;
      return this;
    }

    final public String getClassDefPrefix() {
      return classDefPrefix();
    }

    public String classDefPrefix() {
      return classDefPrefix;
    }

    public String classDefPrefix = "userCode.";

    final public LASClassDef setFullCompilation(boolean fullCompilation) {
      return fullCompilation(fullCompilation);
    }

    public LASClassDef fullCompilation(boolean fullCompilation) {
      this.fullCompilation = fullCompilation;
      return this;
    }

    final public boolean getFullCompilation() {
      return fullCompilation();
    }

    public boolean fullCompilation() {
      return fullCompilation;
    }

    public boolean fullCompilation = false;

    final public LASClassDef setVerbose(boolean verbose) {
      return verbose(verbose);
    }

    public LASClassDef verbose(boolean verbose) {
      this.verbose = verbose;
      return this;
    }

    final public boolean getVerbose() {
      return verbose();
    }

    public boolean verbose() {
      return verbose;
    }

    public boolean verbose = false;

    public List<FieldDef> fields = new ArrayList();

    public List<GazelleV_LeftArrowScript.FunctionDef> methods = new ArrayList();

    public List<GazelleV_LeftArrowScript.FunctionDef> methodBodies = new ArrayList();

    static public class FieldDef {

      final public FieldDef setName(String name) {
        return name(name);
      }

      public FieldDef name(String name) {
        this.name = name;
        return this;
      }

      final public String getName() {
        return name();
      }

      public String name() {
        return name;
      }

      public String name;

      final public FieldDef setType(Class type) {
        return type(type);
      }

      public FieldDef type(Class type) {
        this.type = type;
        return this;
      }

      final public Class getType() {
        return type();
      }

      public Class type() {
        return type;
      }

      public Class type;
    }

    public String structForHash() {
      return struct(litorderedmap("userGivenName", userGivenName, "fields", fields, "methods", methods, "fullCompilation", fullCompilation));
    }

    public String classHash_cache;

    public String classHash() {
      if (classHash_cache == null)
        classHash_cache = classHash_load();
      return classHash_cache;
    }

    public String classHash_load() {
      String struct = structForHash();
      if (verbose)
        print("structForHash", struct);
      return md5(struct);
    }

    public String finalClassName() {
      return classDefPrefix() + finalClassNameWithoutPrefix();
    }

    public String finalClassNameWithoutPrefix() {
      return or2(userGivenName, "C") + "_" + classHash();
    }

    public byte[] toBytes_cache;

    public byte[] toBytes() {
      if (toBytes_cache == null)
        toBytes_cache = toBytes_load();
      return toBytes_cache;
    }

    public byte[] toBytes_load() {
      ClassMaker classMaker = new ClassMaker(finalClassName());
      for (var field : fields) classMaker.addField(new FieldGen(Const.ACC_PUBLIC, classToBCELType(field.type), field.name, classMaker.getConstantPool()));
      for (var method : methods) if (fullCompilation)
        fullyCompileMethod(classMaker, method);
      else
        semiCompileMethod(classMaker, method);
      classMaker.addDefaultConstructor();
      return classMaker.toBytes();
    }

    public void semiCompileMethod(ClassMaker classMaker, GazelleV_LeftArrowScript.FunctionDef method) {
      int iMethod = l(methodBodies);
      methodBodies.add(method);
      String bodyFieldName = "_body" + iMethod;
      classMaker.addField(new FieldGen(Const.ACC_PUBLIC | Const.ACC_STATIC, classToBCELType(GazelleV_LeftArrowScript.Evaluable.class), bodyFieldName, classMaker.getConstantPool()));
      int nArgs = l(method.args);
      MethodMaker mm = new MethodMaker(classMaker, Object.class, method.name, repArray(Class.class, Object.class, nArgs));
      int iThis = 0, iFirstArg = 1, iCtx = iFirstArg + nArgs;
      mm.newObject(VarContext.class);
      mm.astore(iCtx);
      mm.aload(iCtx);
      mm.stringConstant("this");
      mm.aload(iThis);
      mm.invokeVirtual(VarContext.class, void.class, "put", String.class, Object.class);
      for (int iArg = 0; iArg < nArgs; iArg++) {
        mm.aload(iCtx);
        mm.stringConstant(method.args[iArg]);
        mm.aload(iFirstArg + iArg);
        mm.invokeVirtual(VarContext.class, void.class, "put", String.class, Object.class);
      }
      mm.getStaticField(classMaker.className(), bodyFieldName, GazelleV_LeftArrowScript.Evaluable.class);
      mm.aload(iCtx);
      mm.invokeInterface(GazelleV_LeftArrowScript.Evaluable.class, Object.class, "get", VarContext.class);
      mm.areturn();
      mm.done();
    }

    public void fullyCompileMethod(ClassMaker classMaker, GazelleV_LeftArrowScript.FunctionDef method) {
      MethodMaker mm = new MethodMaker(classMaker, Object.class, method.name, repArray(Class.class, Object.class, l(method.args)));
      var tbc = new LASToByteCode(mm) {

        public JVMStackCellType compileGetVar(GazelleV_LeftArrowScript.GetVar code) {
          if (eq(code.var, "this")) {
            mm.aload(0);
            return JVMStackCellType.objValue;
          }
          int iArg = indexOf(method.args, code.var);
          if (iArg >= 0) {
            mm.aload(iArg + 1);
            return JVMStackCellType.objValue;
          }
          return super.compileGetVar(code);
        }
      };
      tbc.postConversion = stackTop -> mm.convertToObject(stackTop);
      tbc.compileScript(method.body);
      mm.areturn();
      mm.done();
    }

    public void init(Class c) {
      for (int iMethod = 0; iMethod < l(methodBodies); iMethod++) {
        String bodyFieldName = "_body" + iMethod;
        set(c, bodyFieldName, methodBodies.get(iMethod).body);
      }
    }
  }

  static public interface IFieldsToList {

    public Object[] _fieldsToList();
  }

  static public interface ISleeper_v2 {

    public Sleeping doLater(Timestamp targetTime, Runnable r);

    public default Sleeping doAfter(double seconds, Runnable r) {
      return doLater(tsNow().plusSeconds(seconds), r);
    }
  }

  static public class SimpleLeftToRightParser extends Meta {

    public String text;

    public List<String> tok;

    final public ListAndIndex<String> getPtr() {
      return ptr();
    }

    public ListAndIndex<String> ptr() {
      return ptr;
    }

    public ListAndIndex<String> ptr;

    public ListAndIndex<String> mainLoopPtr;

    public String currentToken;

    public boolean caseInsensitive = false;

    public List warnings = new ArrayList();

    public SimpleLeftToRightParser() {
    }

    public SimpleLeftToRightParser(String text) {
      this.text = text;
    }

    public SimpleLeftToRightParser(List<String> tok) {
      this.tok = tok;
    }

    transient public IF1<String, List<String>> tokenize;

    public List<String> tokenize(String text) {
      return tokenize != null ? tokenize.get(text) : tokenize_base(text);
    }

    final public List<String> tokenize_fallback(IF1<String, List<String>> _f, String text) {
      return _f != null ? _f.get(text) : tokenize_base(text);
    }

    public List<String> tokenize_base(String text) {
      return javaTok(text);
    }

    final public String token() {
      return t();
    }

    public String t() {
      return currentToken;
    }

    public String token(int i) {
      return get(tok, ptr.idx() + i * 2);
    }

    final public String consume() {
      return next();
    }

    final public String tpp() {
      return next();
    }

    public String next() {
      var t = t();
      next(1);
      return t;
    }

    final public String prevSpace() {
      return lastSpace();
    }

    public String lastSpace() {
      return get(tok, ptr.idx() - 1);
    }

    public String nextSpace() {
      return get(tok, ptr.idx() + 1);
    }

    public String space(int i) {
      return get(tok, ptr.idx() + i * 2 + 1);
    }

    public void unconsume() {
      next(-1);
    }

    final public boolean eqTok(String a, String b) {
      return tokEq(a, b);
    }

    public boolean tokEq(String a, String b) {
      return eqOrEqic(caseInsensitive, a, b);
    }

    public boolean tokEqOneOf(String a, String... l) {
      return any(l, b -> tokEq(a, b));
    }

    public boolean is(int i, String t) {
      return tokEq(token(i), t);
    }

    public boolean is(String t) {
      return tokEq(currentToken, t);
    }

    public boolean was(String t) {
      return tokEq(token(-1), t);
    }

    public boolean isOneOf(String... tokens) {
      return tokEqOneOf(currentToken, tokens);
    }

    public String[] consumeArray(int n) {
      String[] array = new String[n];
      for (int i = 0; i < n; i++) array[i] = consume();
      return array;
    }

    public boolean isInteger() {
      return isInteger(t());
    }

    public boolean isInteger(String s) {
      return main.isInteger(s);
    }

    public boolean isIdentifier() {
      return isIdentifier(t());
    }

    public boolean isIdentifier(String s) {
      return main.isIdentifier(s);
    }

    public String consumeIdentifier() {
      return assertIdentifier(consume());
    }

    public boolean consumeOpt(String token) {
      if (!is(token))
        return false;
      consume();
      return true;
    }

    public void consume(String token) {
      if (!is(token))
        throw fail("Expected " + quote(token) + ", got " + quote(token()));
      consume();
    }

    public String consumeOneOf(String... tokens) {
      if (!isOneOf(tokens))
        throw fail("Expected one of " + asList(tokens));
      return consume();
    }

    public void ptr(ListAndIndex<String> ptr) {
      this.ptr = ptr;
      fetch();
    }

    final public int tokIdx() {
      return idx();
    }

    public int idx() {
      return ptr.idx();
    }

    public int lTok() {
      return l(tok);
    }

    public int nRemainingTokens() {
      return (lTok() - idx()) / 2;
    }

    final public boolean endOfText() {
      return atEnd();
    }

    public boolean atEnd() {
      return ptr.atEnd();
    }

    public void fetch() {
      currentToken = ptr.get();
    }

    public boolean lineBreak() {
      return containsLineBreak(get(tok, ptr.idx() - 1));
    }

    public boolean atEndOrLineBreak() {
      return atEnd() || lineBreak();
    }

    public void init() {
      if (tok == null)
        tok = tokenize(text);
      if (ptr == null)
        ptr(new ListAndIndex(tok, 1));
    }

    public boolean mainLoop() {
      init();
      if (atEnd())
        return false;
      if (eq(mainLoopPtr, ptr))
        throw fail("main loop didn't advance (current token: " + quote(token()) + ")");
      mainLoopPtr = ptr;
      return true;
    }

    public class AssureAdvance {

      public ListAndIndex<String> cur;

      {
        init();
      }

      public boolean get() {
        if (atEnd())
          return false;
        if (eq(cur, ptr))
          throw fail("Parse loop didn't advance (current token: " + quote(token()) + ")");
        cur = ptr;
        return true;
      }
    }

    public void unknownToken() {
      warn("Unknown token: " + t());
    }

    public void warn(String msg) {
      warnings.add(print(msg));
    }

    final public void skip(int n) {
      next(n);
    }

    public void next(int n) {
      ptr(min(lTok(), ptr.idx() + n * 2));
    }

    public void ptr(int i) {
      ptr(new ListAndIndex(tok, min(i | 1, l(tok))));
    }

    public LineAndColumn lineAndColumn() {
      return tokenToLineAndColumn(ptr);
    }

    public LineAndColumn lineAndColumn(int idx) {
      return tokenToLineAndColumn(ptr.plus(idx * 2));
    }

    public String consumeUntilSpaceOr(IF0<Boolean> pred) {
      int i = idx();
      do next(); while (!atEnd() && empty(lastSpace()) && !pred.get());
      return joinSubList(tok, i, idx() - 1);
    }

    public void setText(String text) {
      this.text = text;
      tok = null;
      ptr = null;
    }

    public int relativeIndexOf(String token) {
      int n = nRemainingTokens();
      for (int i = 0; i < n; i++) if (eqTok(token(i), token))
        return i;
      return -1;
    }
  }

  public interface IHasTokenRangeWithSrc {

    public void setTokenRangeWithSrc(TokenRangeWithSrc src);

    public TokenRangeWithSrc tokenRangeWithSrc();

    default public String srcText() {
      var src = tokenRangeWithSrc();
      return src == null ? null : src.text();
    }
  }

  static public class GazelleV_LeftArrowScript {

    abstract static public class Base extends HasTokenRangeWithSrc {

      public RuntimeException rethrowWithSrc(Throwable e) {
        return rethrowWithSrc("", e);
      }

      public RuntimeException rethrowWithSrc(String msg, Throwable e) {
        if (src != null)
          throw rethrowAndAppendToMessage(e, squareBracketed(joinNemptiesWithComma(msg, src)));
        else
          throw rethrow(e);
      }
    }

    public interface Evaluable extends IF0, IHasTokenRangeWithSrc {

      public default Object get() {
        return get(new VarContext());
      }

      public Object get(VarContext ctx);

      public default LASValueDescriptor returnType() {
        return null;
      }

      public default Evaluable optimize() {
        return this;
      }
    }

    abstract static public class EvaluableBase extends Base implements Evaluable {

      final public EvaluableBase setReturnType(LASValueDescriptor returnType) {
        return returnType(returnType);
      }

      public EvaluableBase returnType(LASValueDescriptor returnType) {
        this.returnType = returnType;
        return this;
      }

      final public LASValueDescriptor getReturnType() {
        return returnType();
      }

      public LASValueDescriptor returnType() {
        return returnType;
      }

      public LASValueDescriptor returnType;
    }

    static public AtomicLong scriptIDCounter = new AtomicLong();

    static public long scriptID() {
      return incAtomicLong(scriptIDCounter);
    }

    static public class Script extends Base implements Evaluable {

      transient public long id = scriptID();

      public Map<String, FunctionDef> functionDefs;

      public Evaluable[] steps;

      public Object get(VarContext ctx) {
        Object result = null;
        var pingSource = pingSource();
        for (var step : steps) {
          ping(pingSource);
          result = step.get(ctx);
          var exiting = ctx.exitFromScript;
          if (exiting != null) {
            if (exiting == this) {
              ctx.exitFromScript = null;
              result = ctx.returnValue;
              ctx.returnValue(null);
              return result;
            }
            return null;
          }
        }
        return result;
      }

      public String toStringLong() {
        return pnlToLines(steps);
      }

      public String toString() {
        return "Script " + n2(id);
      }

      public FunctionDef getFunction(String name) {
        return mapGet(functionDefs, name);
      }
    }

    static public class FunctionDef extends Base implements IFieldsToList {

      public String name;

      public String[] args;

      public Script body;

      public FunctionDef() {
      }

      public FunctionDef(String name, String[] args, Script body) {
        this.body = body;
        this.args = args;
        this.name = name;
      }

      public String toString() {
        return shortClassName_dropNumberPrefix(this) + "(" + name + ", " + args + ", " + body + ")";
      }

      public Object[] _fieldsToList() {
        return new Object[] { name, args, body };
      }

      public FunctionDef(String name, List<String> args, Script body) {
        this.args = toStringArray(args);
        this.body = body;
        this.name = name;
      }

      public Object call(VarContext ctx, Object... args) {
        var ctx2 = new VarContext(ctx);
        int n = min(l(args), l(this.args));
        for (int i = 0; i < n; i++) ctx2.put(this.args[i], args[i]);
        return body.get(ctx2);
      }
    }

    static public class Assignment extends Base implements Evaluable, IFieldsToList {

      public String var;

      public Evaluable expression;

      public Assignment() {
      }

      public Assignment(String var, Evaluable expression) {
        this.expression = expression;
        this.var = var;
      }

      public Object[] _fieldsToList() {
        return new Object[] { var, expression };
      }

      public Object get(VarContext ctx) {
        Object o = expression.get(ctx);
        ctx.set(var, o);
        return o;
      }

      public String toString() {
        return var + " <- " + expression;
      }
    }

    static public class VarDeclaration extends EvaluableBase implements IFieldsToList {

      public String var;

      public Class type;

      public Evaluable expression;

      public VarDeclaration() {
      }

      public VarDeclaration(String var, Class type, Evaluable expression) {
        this.expression = expression;
        this.type = type;
        this.var = var;
      }

      public Object[] _fieldsToList() {
        return new Object[] { var, type, expression };
      }

      public Object get(VarContext ctx) {
        Object o = expression == null ? null : expression.get(ctx);
        ctx.set(var, o);
        return o;
      }

      public String toString() {
        return "var " + var + " <- " + expression;
      }
    }

    static public class AssignmentToOuterVar extends EvaluableBase implements IFieldsToList {

      public String var;

      public Evaluable expression;

      public AssignmentToOuterVar() {
      }

      public AssignmentToOuterVar(String var, Evaluable expression) {
        this.expression = expression;
        this.var = var;
      }

      public Object[] _fieldsToList() {
        return new Object[] { var, expression };
      }

      public Object get(VarContext ctx) {
        var parent = ctx.parent();
        assertNotNull("No outer variable context", parent);
        Object o = expression.get(ctx);
        parent.set(var, o);
        return o;
      }

      public String toString() {
        return "outer " + var + " <- " + expression;
      }
    }

    static public class NewObject extends Base implements Evaluable {

      public NewObject() {
      }

      public Class c;

      public Evaluable[] args;

      public NewObject(Class c) {
        this.c = c;
      }

      public NewObject(Class c, Evaluable[] args) {
        this.args = args;
        this.c = c;
      }

      public Object get(VarContext ctx) {
        try {
          return preciseNuObject(c, mapToArrayOrNull(args, arg -> arg.get(ctx)));
        } catch (Throwable e) {
          throw rethrowWithSrc(e);
        }
      }

      public String toString() {
        return "new " + formatFunctionCall(className(c), args);
      }
    }

    static public class NewObject_LASClass extends NewObject {

      public NewObject_LASClass() {
      }

      public ResolvableLASClass lasClass;

      public NewObject_LASClass(ResolvableLASClass lasClass) {
        this.lasClass = lasClass;
      }

      public NewObject_LASClass(ResolvableLASClass lasClass, Evaluable[] args) {
        this.args = args;
        this.lasClass = lasClass;
      }

      public void resolve() {
        if (c == null)
          c = lasClass.get();
      }

      public Object get(VarContext ctx) {
        resolve();
        return super.get(ctx);
      }

      public String toString() {
        return "new " + formatFunctionCall(str(lasClass), args);
      }
    }

    static public class NewObject_UnknownClass extends NewObject implements IFieldsToList {

      public Evaluable classExpr;

      public Evaluable[] args;

      public NewObject_UnknownClass() {
      }

      public NewObject_UnknownClass(Evaluable classExpr, Evaluable[] args) {
        this.args = args;
        this.classExpr = classExpr;
      }

      public Object[] _fieldsToList() {
        return new Object[] { classExpr, args };
      }

      public Object get(VarContext ctx) {
        try {
          Class c = (Class) (classExpr.get(ctx));
          return preciseNuObject(c, mapToArrayOrNull(args, arg -> arg.get(ctx)));
        } catch (Throwable e) {
          throw rethrowWithSrc(e);
        }
      }

      public String toString() {
        return "new " + formatFunctionCall(classExpr, args);
      }
    }

    static public class CallFunction extends Base implements Evaluable, IFieldsToList {

      public FunctionDef f;

      public Evaluable[] args;

      public CallFunction() {
      }

      public CallFunction(FunctionDef f, Evaluable[] args) {
        this.args = args;
        this.f = f;
      }

      public Object[] _fieldsToList() {
        return new Object[] { f, args };
      }

      public Object get(VarContext ctx) {
        var evaledArgs = mapToArrayOrNull(args, a -> a.get(ctx));
        if (ctx.exiting())
          return null;
        return f.call(ctx, evaledArgs);
      }

      public String toString() {
        return formatFunctionCall(f.name, args);
      }
    }

    static public class GetVar extends EvaluableBase implements IFieldsToList {

      public String var;

      public GetVar() {
      }

      public GetVar(String var) {
        this.var = var;
      }

      public Object[] _fieldsToList() {
        return new Object[] { var };
      }

      public Object get(VarContext ctx) {
        return ctx.get(var);
      }

      public String toString() {
        return var;
      }
    }

    static public class Const extends Base implements Evaluable, IFieldsToList {

      public Object value;

      public Const() {
      }

      public Const(Object value) {
        this.value = value;
      }

      public Object[] _fieldsToList() {
        return new Object[] { value };
      }

      public Object get(VarContext ctx) {
        return value;
      }

      public String toString() {
        return strOrClassName(value);
      }

      public LASValueDescriptor returnType() {
        return new LASValueDescriptor.KnownValue(value);
      }
    }

    static public class GetStaticField extends Base implements Evaluable, IFieldsToList {

      public Field field;

      public GetStaticField() {
      }

      public GetStaticField(Field field) {
        this.field = field;
      }

      public String toString() {
        return shortClassName_dropNumberPrefix(this) + "(" + field + ")";
      }

      public Object[] _fieldsToList() {
        return new Object[] { field };
      }

      public Object get(VarContext ctx) {
        try {
          return field.get(null);
        } catch (Exception __e) {
          throw rethrow(__e);
        }
      }
    }

    static public class CallMethodOrGetField extends Base implements Evaluable, IFieldsToList {

      public Evaluable target;

      public String name;

      public CallMethodOrGetField() {
      }

      public CallMethodOrGetField(Evaluable target, String name) {
        this.name = name;
        this.target = target;
      }

      public String toString() {
        return shortClassName_dropNumberPrefix(this) + "(" + target + ", " + name + ")";
      }

      public Object[] _fieldsToList() {
        return new Object[] { target, name };
      }

      final public CallMethodOrGetField setAllowNullReference(boolean allowNullReference) {
        return allowNullReference(allowNullReference);
      }

      public CallMethodOrGetField allowNullReference(boolean allowNullReference) {
        this.allowNullReference = allowNullReference;
        return this;
      }

      final public boolean getAllowNullReference() {
        return allowNullReference();
      }

      public boolean allowNullReference() {
        return allowNullReference;
      }

      public boolean allowNullReference = false;

      public Object handleNullReference() {
        if (allowNullReference)
          return null;
        else
          throw new NullPointerException();
      }

      public Object get(VarContext ctx) {
        try {
          Object object = target.get(ctx);
          if (object == null)
            return handleNullReference();
          return preciseGetOrCallMethod(object, name);
        } catch (Throwable e) {
          throw rethrowWithSrc("Was getting " + name, e);
        }
      }
    }

    static public class GetVarContext extends Base implements Evaluable {

      public Object get(VarContext ctx) {
        return ctx;
      }
    }

    static public class ThrowMethodNotFoundException extends Base implements Evaluable, IFieldsToList {

      public CallMethod instruction;

      public ThrowMethodNotFoundException() {
      }

      public ThrowMethodNotFoundException(CallMethod instruction) {
        this.instruction = instruction;
      }

      public String toString() {
        return shortClassName_dropNumberPrefix(this) + "(" + instruction + ")";
      }

      public Object[] _fieldsToList() {
        return new Object[] { instruction };
      }

      public Object get(VarContext ctx) {
        throw fail("Method not found: " + instruction);
      }
    }

    static public class ThrowNullPointerException extends Base implements Evaluable, IFieldsToList {

      public CallMethod instruction;

      public ThrowNullPointerException() {
      }

      public ThrowNullPointerException(CallMethod instruction) {
        this.instruction = instruction;
      }

      public String toString() {
        return shortClassName_dropNumberPrefix(this) + "(" + instruction + ")";
      }

      public Object[] _fieldsToList() {
        return new Object[] { instruction };
      }

      public Object get(VarContext ctx) {
        throw fail("Null pointer exception: " + instruction);
      }
    }

    static public class CallMethod extends Base implements Evaluable, IFieldsToList {

      public Evaluable target;

      public String methodName;

      public Evaluable[] args;

      public CallMethod() {
      }

      public CallMethod(Evaluable target, String methodName, Evaluable[] args) {
        this.args = args;
        this.methodName = methodName;
        this.target = target;
      }

      public Object[] _fieldsToList() {
        return new Object[] { target, methodName, args };
      }

      public Object get(VarContext ctx) {
        return newPreciseCall(target.get(ctx), methodName, mapToArrayOrNull(args, arg -> arg.get(ctx)));
      }

      public String toString() {
        return target + "." + formatFunctionCall(methodName, args);
      }

      public Evaluable optimize() {
        var targetType = target.returnType();
        if (targetType.knownValue()) {
          Object o = targetType.value();
          if (o == null)
            return new ThrowNullPointerException(this);
          Class[] argTypes = new Class[l(args)];
          for (int i = 0; i < l(args); i++) {
            var type = args[i].returnType();
            if (!type.javaClassIsExact())
              return this;
            argTypes[i] = type.javaClass();
          }
          var method = findMethod_precise_onTypes(o, methodName, argTypes);
          if (method == null)
            return new ThrowMethodNotFoundException(this);
          return new DirectMethodCallOnKnownTarget(o instanceof Class ? null : o, method, args);
        }
        return this;
      }
    }

    static public class LambdaDef extends Base implements Evaluable, IFieldsToList {

      public Class intrface;

      public String[] args;

      public Evaluable body;

      public LambdaDef() {
      }

      public String toString() {
        return shortClassName_dropNumberPrefix(this) + "(" + intrface + ", " + args + ", " + body + ")";
      }

      public Object[] _fieldsToList() {
        return new Object[] { intrface, args, body };
      }

      public Method implementedMethod;

      public LambdaDef(Class intrface, String[] args, Evaluable body) {
        this.body = body;
        this.args = args;
        this.intrface = intrface;
        implementedMethod = findSingleInterfaceMethodOrFail(intrface);
        if (implementedMethod.getParameterCount() != l(args))
          throw fail("Bad parameter count for lambda: " + implementedMethod + " vs: " + joinWithComma(args));
      }

      public Object get(VarContext ctx) {
        return proxyFromInvocationHandler(intrface, (proxy, method, actualArgs) -> {
          ping();
          if (method.getDeclaringClass() == intrface) {
            var ctx2 = new VarContext(ctx);
            var argNames = args;
            for (int i = 0; i < l(args); i++) ctx2.put(argNames[i], actualArgs[i]);
            return body.get(ctx2);
          } else
            return handleObjectMethodsInProxyInvocationHandler(this, implementedMethod, method, proxy, actualArgs);
        });
      }
    }

    abstract static public class CurriedLambdaBase extends Base implements Evaluable, IFieldsToList {

      public Class intrface;

      public Evaluable[] curriedArgs;

      public CurriedLambdaBase() {
      }

      public String toString() {
        return shortClassName_dropNumberPrefix(this) + "(" + intrface + ", " + curriedArgs + ")";
      }

      public Object[] _fieldsToList() {
        return new Object[] { intrface, curriedArgs };
      }

      public Method implementedMethod;

      public CurriedLambdaBase(Class intrface, Evaluable[] curriedArgs) {
        this.curriedArgs = curriedArgs;
        this.intrface = intrface;
        implementedMethod = findSingleInterfaceMethodOrFail(intrface);
      }

      public Object get(VarContext ctx) {
        Object[] curriedArguments = mapToArrayOrNull(curriedArgs, arg -> arg.get(ctx));
        return proxyFromInvocationHandler(intrface, (proxy, method, actualArgs) -> {
          if (method.getDeclaringClass() == intrface)
            return forwardCall(ctx, concatMethodArgs(curriedArguments, actualArgs));
          else
            return handleObjectMethodsInProxyInvocationHandler(this, implementedMethod, method, proxy, actualArgs);
        });
      }

      abstract public Object forwardCall(VarContext ctx, Object[] args);
    }

    static public class CurriedMethodLambda extends CurriedLambdaBase {

      public Object target;

      public String targetMethod;

      public CurriedMethodLambda(Class intrface, Object target, String targetMethod, Evaluable[] curriedArgs) {
        super(intrface, curriedArgs);
        this.targetMethod = targetMethod;
        this.target = target;
      }

      public Object forwardCall(VarContext ctx, Object[] args) {
        return call(target, targetMethod, args);
      }
    }

    static public class CurriedScriptFunctionLambda extends CurriedLambdaBase {

      public FunctionDef f;

      public CurriedScriptFunctionLambda(Class intrface, FunctionDef f, Evaluable[] curriedArgs) {
        super(intrface, curriedArgs);
        this.f = f;
      }

      public Object forwardCall(VarContext ctx, Object[] args) {
        return f.call(ctx, args);
      }
    }

    static public class CurriedConstructorLambda extends CurriedLambdaBase {

      public Constructor[] ctors;

      public CurriedConstructorLambda(Class intrface, Constructor[] ctors, Evaluable[] curriedArgs) {
        super(intrface, curriedArgs);
        this.ctors = ctors;
      }

      public Object forwardCall(VarContext ctx, Object[] args) {
        return preciseNuObject(ctors, args);
      }
    }

    static public class DirectMethodCallOnKnownTarget extends Base implements Evaluable, IFieldsToList {

      public Object target;

      public Method method;

      public Evaluable[] args;

      public DirectMethodCallOnKnownTarget() {
      }

      public DirectMethodCallOnKnownTarget(Object target, Method method, Evaluable[] args) {
        this.args = args;
        this.method = method;
        this.target = target;
      }

      public Object[] _fieldsToList() {
        return new Object[] { target, method, args };
      }

      public Object get(VarContext ctx) {
        return invokeMethod(method, target, mapToArrayOrNull(args, arg -> arg.get(ctx)));
      }

      public String toString() {
        return (target == null ? "" : target + ".") + formatFunctionCall(str(method), args);
      }

      public LASValueDescriptor returnType() {
        return LASValueDescriptor.fromClass(method.getReturnType());
      }
    }

    static public class While extends Base implements Evaluable, IFieldsToList {

      public Evaluable condition;

      public Evaluable body;

      public While() {
      }

      public While(Evaluable condition, Evaluable body) {
        this.body = body;
        this.condition = condition;
      }

      public String toString() {
        return shortClassName_dropNumberPrefix(this) + "(" + condition + ", " + body + ")";
      }

      public Object[] _fieldsToList() {
        return new Object[] { condition, body };
      }

      public Object get(VarContext ctx) {
        while (!ctx.exiting() && (Boolean) condition.get(ctx)) {
          body.get(ctx);
        }
        return null;
      }
    }

    abstract static public class ForEachBase extends Base implements Evaluable, IFieldsToList {

      public Evaluable collection;

      public Evaluable body;

      public ForEachBase() {
      }

      public ForEachBase(Evaluable collection, Evaluable body) {
        this.body = body;
        this.collection = collection;
      }

      public String toString() {
        return shortClassName_dropNumberPrefix(this) + "(" + collection + ", " + body + ")";
      }

      public Object[] _fieldsToList() {
        return new Object[] { collection, body };
      }

      public Object get(VarContext ctx) {
        var coll = collection.get(ctx);
        Iterator iterator;
        List out;
        try {
          if (coll instanceof Object[]) {
            out = emptyList(((Object[]) coll).length);
            for (var element : ((Object[]) coll)) {
              if (ctx.exiting())
                return null;
              processElement(ctx, out, element);
            }
          } else if (coll instanceof Iterable) {
            out = emptyList((Iterable) coll);
            for (var element : ((Iterable) coll)) {
              if (ctx.exiting())
                return null;
              processElement(ctx, out, element);
            }
          } else if (coll == null)
            out = new ArrayList();
          else
            throw fail("Not iterable: " + className(coll));
        } finally {
          loopDone(ctx);
        }
        return out;
      }

      abstract public void processElement(VarContext ctx, List out, Object o);

      abstract public void loopDone(VarContext ctx);
    }

    static public class ForEach extends ForEachBase {

      public ForEach() {
      }

      public String var;

      public ForEach(Evaluable collection, String var, Evaluable body) {
        this.body = body;
        this.var = var;
        this.collection = collection;
      }

      public void processElement(VarContext ctx, List out, Object o) {
        ctx.set(var, o);
        out.add(body.get(ctx));
      }

      public void loopDone(VarContext ctx) {
        ctx.unset(var);
      }
    }

    static public class ForIterator extends Base implements Evaluable, IFieldsToList {

      static final public String _fieldOrder = "iterable var body";

      public Evaluable iterable;

      public String var;

      public Evaluable body;

      public ForIterator() {
      }

      public ForIterator(Evaluable iterable, String var, Evaluable body) {
        this.body = body;
        this.var = var;
        this.iterable = iterable;
      }

      public String toString() {
        return shortClassName_dropNumberPrefix(this) + "(" + iterable + ", " + var + ", " + body + ")";
      }

      public boolean equals(Object o) {
        if (!(o instanceof ForIterator))
          return false;
        ForIterator __4 = (ForIterator) o;
        return eq(iterable, __4.iterable) && eq(var, __4.var) && eq(body, __4.body);
      }

      public int hashCode() {
        int h = -214906825;
        h = boostHashCombine(h, _hashCode(iterable));
        h = boostHashCombine(h, _hashCode(var));
        h = boostHashCombine(h, _hashCode(body));
        return h;
      }

      public Object[] _fieldsToList() {
        return new Object[] { iterable, var, body };
      }

      public Object get(VarContext ctx) {
        VarContext subContext = new VarContext(ctx);
        var iterable = this.iterable.get(ctx);
        Iterator iterator = iterator_gen(iterable);
        return mapI(iterator, value -> {
          subContext.set(var, value);
          return body.get(subContext);
        });
      }
    }

    static public class ForNested extends Base implements Evaluable, IFieldsToList {

      static final public String _fieldOrder = "iterable var body";

      public Evaluable iterable;

      public String var;

      public Evaluable body;

      public ForNested() {
      }

      public ForNested(Evaluable iterable, String var, Evaluable body) {
        this.body = body;
        this.var = var;
        this.iterable = iterable;
      }

      public String toString() {
        return shortClassName_dropNumberPrefix(this) + "(" + iterable + ", " + var + ", " + body + ")";
      }

      public boolean equals(Object o) {
        if (!(o instanceof ForNested))
          return false;
        ForNested __5 = (ForNested) o;
        return eq(iterable, __5.iterable) && eq(var, __5.var) && eq(body, __5.body);
      }

      public int hashCode() {
        int h = -1363247360;
        h = boostHashCombine(h, _hashCode(iterable));
        h = boostHashCombine(h, _hashCode(var));
        h = boostHashCombine(h, _hashCode(body));
        return h;
      }

      public Object[] _fieldsToList() {
        return new Object[] { iterable, var, body };
      }

      public Object get(VarContext ctx) {
        VarContext subContext = new VarContext(ctx);
        var iterable = this.iterable.get(ctx);
        Iterator iterator = iterator_gen(iterable);
        return nestedIterator(iterator, value -> {
          subContext.set(var, value);
          return iterator_gen(body.get(subContext));
        });
      }
    }

    static public class ForPairs extends ForEachBase {

      public ForPairs() {
      }

      public String varA, varB;

      public ForPairs(Evaluable collection, Evaluable body, String varA, String varB) {
        this.varB = varB;
        this.varA = varA;
        this.body = body;
        this.collection = collection;
      }

      public void processElement(VarContext ctx, List out, Object o) {
        Pair p = (Pair) o;
        ctx.set(varA, p.a);
        ctx.set(varB, p.b);
        out.add(body.get(ctx));
      }

      public void loopDone(VarContext ctx) {
        ctx.unset(varA);
        ctx.unset(varB);
      }
    }

    static public class ForKeyValue extends Base implements Evaluable, IFieldsToList {

      public Evaluable map;

      public Evaluable body;

      public String varA;

      public String varB;

      public ForKeyValue() {
      }

      public ForKeyValue(Evaluable map, Evaluable body, String varA, String varB) {
        this.varB = varB;
        this.varA = varA;
        this.body = body;
        this.map = map;
      }

      public String toString() {
        return shortClassName_dropNumberPrefix(this) + "(" + map + ", " + body + ", " + varA + ", " + varB + ")";
      }

      public Object[] _fieldsToList() {
        return new Object[] { map, body, varA, varB };
      }

      public Object get(VarContext ctx) {
        Map<?, ?> theMap = (Map) map.get(ctx);
        List out;
        try {
          if (theMap != null) {
            out = emptyList(theMap.size());
            for (var entry : theMap.entrySet()) {
              if (ctx.exiting())
                return null;
              ctx.set(varA, entry.getKey());
              ctx.set(varB, entry.getValue());
              out.add(body.get(ctx));
            }
          } else
            out = new ArrayList();
        } finally {
          ctx.unset(varA);
          ctx.unset(varB);
        }
        return out;
      }
    }

    static public class ForIndex extends EvaluableBase {

      public ForIndex() {
      }

      public Evaluable collection, body;

      public String varIndex, varElement;

      public ForIndex(Evaluable collection, Evaluable body, String varIndex, String varElement) {
        this.varElement = varElement;
        this.varIndex = varIndex;
        this.body = body;
        this.collection = collection;
      }

      public Object get(VarContext ctx) {
        return new ForIndex_instance(collection, body, varIndex, varElement).get(ctx);
      }
    }

    static public class ForIndex_instance extends ForEachBase {

      public String varIndex, varElement;

      public int index;

      public ForIndex_instance(Evaluable collection, Evaluable body, String varIndex, String varElement) {
        this.varElement = varElement;
        this.varIndex = varIndex;
        this.body = body;
        this.collection = collection;
      }

      public void processElement(VarContext ctx, List out, Object o) {
        ctx.set(varIndex, index++);
        ctx.set(varElement, o);
        out.add(body.get(ctx));
      }

      public void loopDone(VarContext ctx) {
        ctx.unset(varIndex);
        ctx.unset(varElement);
      }
    }

    static public class IfThen extends Base implements Evaluable, IFieldsToList {

      public Evaluable condition;

      public Evaluable body;

      public Evaluable elseBranch;

      public IfThen() {
      }

      public IfThen(Evaluable condition, Evaluable body, Evaluable elseBranch) {
        this.elseBranch = elseBranch;
        this.body = body;
        this.condition = condition;
      }

      public String toString() {
        return shortClassName_dropNumberPrefix(this) + "(" + condition + ", " + body + ", " + elseBranch + ")";
      }

      public Object[] _fieldsToList() {
        return new Object[] { condition, body, elseBranch };
      }

      public IfThen(Evaluable condition, Evaluable body) {
        this.condition = condition;
        this.body = body;
      }

      public Object get(VarContext ctx) {
        if ((Boolean) condition.get(ctx))
          return body.get(ctx);
        else if (elseBranch != null)
          return elseBranch.get(ctx);
        else
          return null;
      }
    }

    static public class ReturnFromScript extends Base implements Evaluable, IFieldsToList {

      public Script script;

      public Evaluable value;

      public ReturnFromScript() {
      }

      public ReturnFromScript(Script script, Evaluable value) {
        this.value = value;
        this.script = script;
      }

      public Object[] _fieldsToList() {
        return new Object[] { script, value };
      }

      public Object get(VarContext ctx) {
        Object result = value.get(ctx);
        ctx.exitFromScript(script);
        ctx.returnValue(result);
        return null;
      }

      public String toString() {
        return formatFunctionCall("ReturnFromScript", script, value);
      }
    }

    static public class Continue extends Base implements Evaluable, IFieldsToList {

      public Script loopBody;

      public Continue() {
      }

      public Continue(Script loopBody) {
        this.loopBody = loopBody;
      }

      public Object[] _fieldsToList() {
        return new Object[] { loopBody };
      }

      public Object get(VarContext ctx) {
        ctx.exitFromScript(loopBody);
        ctx.returnValue(null);
        return null;
      }

      public String toString() {
        return formatFunctionCall("Continue", loopBody);
      }
    }

    static public class RepeatN extends Base implements Evaluable, IFieldsToList {

      public Evaluable n;

      public Evaluable body;

      public RepeatN() {
      }

      public RepeatN(Evaluable n, Evaluable body) {
        this.body = body;
        this.n = n;
      }

      public String toString() {
        return shortClassName_dropNumberPrefix(this) + "(" + n + ", " + body + ")";
      }

      public Object[] _fieldsToList() {
        return new Object[] { n, body };
      }

      public Object get(VarContext ctx) {
        long count = ((Number) n.get(ctx)).longValue();
        for (int _repeat_0 = 0; _repeat_0 < count; _repeat_0++) {
          if (ctx.exiting())
            return null;
          body.get(ctx);
        }
        return null;
      }
    }

    static public class BoolAnd extends Base implements Evaluable, IFieldsToList {

      public Evaluable a;

      public Evaluable b;

      public BoolAnd() {
      }

      public BoolAnd(Evaluable a, Evaluable b) {
        this.b = b;
        this.a = a;
      }

      public String toString() {
        return shortClassName_dropNumberPrefix(this) + "(" + a + ", " + b + ")";
      }

      public boolean equals(Object o) {
        if (!(o instanceof BoolAnd))
          return false;
        BoolAnd __6 = (BoolAnd) o;
        return eq(a, __6.a) && eq(b, __6.b);
      }

      public int hashCode() {
        int h = 1729330797;
        h = boostHashCombine(h, _hashCode(a));
        h = boostHashCombine(h, _hashCode(b));
        return h;
      }

      public Object[] _fieldsToList() {
        return new Object[] { a, b };
      }

      public Object get(VarContext ctx) {
        if (!((Boolean) a.get(ctx)))
          return false;
        return b.get(ctx);
      }
    }

    static public class BoolOr extends Base implements Evaluable, IFieldsToList {

      public Evaluable a;

      public Evaluable b;

      public BoolOr() {
      }

      public BoolOr(Evaluable a, Evaluable b) {
        this.b = b;
        this.a = a;
      }

      public String toString() {
        return shortClassName_dropNumberPrefix(this) + "(" + a + ", " + b + ")";
      }

      public boolean equals(Object o) {
        if (!(o instanceof BoolOr))
          return false;
        BoolOr __7 = (BoolOr) o;
        return eq(a, __7.a) && eq(b, __7.b);
      }

      public int hashCode() {
        int h = 1995447949;
        h = boostHashCombine(h, _hashCode(a));
        h = boostHashCombine(h, _hashCode(b));
        return h;
      }

      public Object[] _fieldsToList() {
        return new Object[] { a, b };
      }

      public Object get(VarContext ctx) {
        if (((Boolean) a.get(ctx)))
          return true;
        return b.get(ctx);
      }
    }

    static public class TempBlock extends Base implements Evaluable, IFieldsToList {

      public Evaluable tempExpr;

      public Evaluable body;

      public TempBlock() {
      }

      public TempBlock(Evaluable tempExpr, Evaluable body) {
        this.body = body;
        this.tempExpr = tempExpr;
      }

      public String toString() {
        return shortClassName_dropNumberPrefix(this) + "(" + tempExpr + ", " + body + ")";
      }

      public Object[] _fieldsToList() {
        return new Object[] { tempExpr, body };
      }

      public Object get(VarContext ctx) {
        AutoCloseable __2 = (AutoCloseable) (tempExpr.get(ctx));
        try {
          return body.get(ctx);
        } finally {
          _close(__2);
        }
      }
    }

    static public class ClassDef extends Base implements Evaluable, IFieldsToList {

      public ResolvableLASClass lasClass;

      public ClassDef() {
      }

      public ClassDef(ResolvableLASClass lasClass) {
        this.lasClass = lasClass;
      }

      public String toString() {
        return shortClassName_dropNumberPrefix(this) + "(" + lasClass + ")";
      }

      public boolean equals(Object o) {
        if (!(o instanceof ClassDef))
          return false;
        ClassDef __8 = (ClassDef) o;
        return eq(lasClass, __8.lasClass);
      }

      public int hashCode() {
        int h = 757052301;
        h = boostHashCombine(h, _hashCode(lasClass));
        return h;
      }

      public Object[] _fieldsToList() {
        return new Object[] { lasClass };
      }

      public Object get(VarContext ctx) {
        return lasClass.get();
      }
    }

    static public class SetField extends Base implements Evaluable, IFieldsToList {

      public Evaluable target;

      public String name;

      public Evaluable expr;

      public SetField() {
      }

      public SetField(Evaluable target, String name, Evaluable expr) {
        this.expr = expr;
        this.name = name;
        this.target = target;
      }

      public String toString() {
        return shortClassName_dropNumberPrefix(this) + "(" + target + ", " + name + ", " + expr + ")";
      }

      public Object[] _fieldsToList() {
        return new Object[] { target, name, expr };
      }

      final public SetField setAllowNullReference(boolean allowNullReference) {
        return allowNullReference(allowNullReference);
      }

      public SetField allowNullReference(boolean allowNullReference) {
        this.allowNullReference = allowNullReference;
        return this;
      }

      final public boolean getAllowNullReference() {
        return allowNullReference();
      }

      public boolean allowNullReference() {
        return allowNullReference;
      }

      public boolean allowNullReference = false;

      public Object handleNullReference() {
        if (allowNullReference)
          return null;
        else
          throw new NullPointerException();
      }

      public Object get(VarContext ctx) {
        try {
          Object value = expr.get(ctx);
          Object object = target.get(ctx);
          if (object == null)
            handleNullReference();
          else
            set(object, name, value);
          return value;
        } catch (Throwable e) {
          throw rethrowWithSrc(e);
        }
      }
    }

    static public class Throw extends Base implements Evaluable, IFieldsToList {

      public Evaluable expr;

      public Throw() {
      }

      public Throw(Evaluable expr) {
        this.expr = expr;
      }

      public String toString() {
        return shortClassName_dropNumberPrefix(this) + "(" + expr + ")";
      }

      public Object[] _fieldsToList() {
        return new Object[] { expr };
      }

      public Object get(VarContext ctx) {
        throw asRuntimeException((Throwable) expr.get(ctx));
      }
    }

    static public class TryCatch extends Base implements Evaluable, IFieldsToList {

      public Evaluable body;

      public String var;

      public Evaluable catchBlock;

      public TryCatch() {
      }

      public TryCatch(Evaluable body, String var, Evaluable catchBlock) {
        this.catchBlock = catchBlock;
        this.var = var;
        this.body = body;
      }

      public String toString() {
        return shortClassName_dropNumberPrefix(this) + "(" + body + ", " + var + ", " + catchBlock + ")";
      }

      public Object[] _fieldsToList() {
        return new Object[] { body, var, catchBlock };
      }

      public Object get(VarContext ctx) {
        try {
          return body.get(ctx);
        } catch (Throwable e) {
          AutoCloseable __3 = ctx.tempPut(var, e);
          try {
            return catchBlock.get(ctx);
          } finally {
            _close(__3);
          }
        }
      }
    }
  }

  public interface IMultiMap<A, B> {

    public Set<A> keySet();

    public Collection<B> get(A a);

    public int size();

    public int keyCount();
  }

  public interface IVarWithNotify<A> extends IVar<A>, IF0WithChangeListeners<A> {

    default public IVarWithNotify<A> onChange(IVF1<A> r) {
      if (r == null)
        return this;
      onChange(() -> r.get(get()));
      return this;
    }

    default public IVarWithNotify<A> onChangeAndNow(IVF1<A> r) {
      if (r == null)
        return this;
      onChangeAndNow(() -> r.get(get()));
      return this;
    }
  }

  public interface Enterable {

    public AutoCloseable enter();
  }

  static public class Meta implements IMeta {

    volatile public Object meta;

    public void _setMeta(Object meta) {
      this.meta = meta;
    }

    public Object _getMeta() {
      return meta;
    }

    final public boolean scaffolding() {
      return scaffoldingEnabled();
    }

    public boolean scaffoldingEnabled() {
      return main.scaffoldingEnabled(this);
    }

    public boolean scaffoldingEnabled(Object o) {
      return main.scaffoldingEnabled(o);
    }
  }

  public enum JVMStackCellType {

    none,
    objValue,
    intValue,
    longValue,
    floatValue,
    doubleValue
  }

  static public class ClassNameResolver {

    final public ClassNameResolver setByteCodePath(File byteCodePath) {
      return byteCodePath(byteCodePath);
    }

    public ClassNameResolver byteCodePath(File byteCodePath) {
      this.byteCodePath = byteCodePath;
      return this;
    }

    final public File getByteCodePath() {
      return byteCodePath();
    }

    public File byteCodePath() {
      return byteCodePath;
    }

    public File byteCodePath = byteCodePathForClass(getClass());

    public List<String> importedPackages = itemPlusList("java.lang", endingWith_dropSuffix(standardImports(), ".*"));

    public Set<String> allFullyQualifiedClassNames_cache;

    public Set<String> allFullyQualifiedClassNames() {
      if (allFullyQualifiedClassNames_cache == null)
        allFullyQualifiedClassNames_cache = allFullyQualifiedClassNames_load();
      return allFullyQualifiedClassNames_cache;
    }

    public Set<String> allFullyQualifiedClassNames_load() {
      Set<String> set = new HashSet();
      assertNotNull(byteCodePath);
      set.addAll(classNamesInJarOrDir(byteCodePath));
      printVars("ClassNameResolver", "byteCodePath", byteCodePath, "classesFound", l(set));
      set.addAll(classNamesInLoadedJigsawModules());
      return set;
    }

    public ClassNameResolver init() {
      allFullyQualifiedClassNames();
      return this;
    }

    public String findClass(String name) {
      for (String pkg : importedPackages) {
        String fullName = pkg + "." + name;
        if (allFullyQualifiedClassNames().contains(fullName))
          return fullName;
      }
      return null;
    }

    public void printMe() {
      printVars("ClassNameResolver", "byteCodePath", byteCodePath);
      print("importedPackages", importedPackages);
    }
  }

  public interface G22ProjectActions {

    public void openObjectInProject(long id);

    public void openPathInProject(String path);

    public void editProjectStory();

    public void editScripts();
  }

  static public class Timestamp implements Comparable<Timestamp>, IFieldsToList {

    public long date;

    public Timestamp(long date) {
      this.date = date;
    }

    public boolean equals(Object o) {
      if (!(o instanceof Timestamp))
        return false;
      Timestamp __1 = (Timestamp) o;
      return date == __1.date;
    }

    public int hashCode() {
      int h = 2059094262;
      h = boostHashCombine(h, _hashCode(date));
      return h;
    }

    public Object[] _fieldsToList() {
      return new Object[] { date };
    }

    public Timestamp() {
      date = now();
    }

    public long unixDate() {
      return date;
    }

    public String toString() {
      return formatLocalDateWithSeconds(date);
    }

    public int compareTo(Timestamp t) {
      return t == null ? 1 : cmp(date, t.date);
    }

    public Timestamp plus(Seconds seconds) {
      return plus(seconds == null ? null : seconds.getDouble());
    }

    final public Timestamp plusSeconds(double seconds) {
      return plus(seconds);
    }

    public Timestamp plus(double seconds) {
      return new Timestamp(date + toMS(seconds));
    }

    public long minus(Timestamp ts) {
      return unixDate() - ts.unixDate();
    }

    public long sysTime() {
      return clockTimeToSystemTime(date);
    }

    public Duration minusAsDuration(Timestamp ts) {
      return Duration.ofMillis(minus(ts));
    }
  }

  static public class CombinedStringifier<A> implements IStringifier<A> {

    public CopyOnWriteArrayList<IPartialStringifier<A>> stringifiers = new CopyOnWriteArrayList();

    public IStringifier<A> defaultStringifier = new Stringifier_ToString();

    public CombinedStringifier(IPartialStringifier<A>... stringifiers) {
      addAll(this.stringifiers, stringifiers);
    }

    public String toString(A o) {
      for (var stringifier : stringifiers) {
        String s = stringifier.toStringOpt(o);
        if (s != null)
          return s;
      }
      return defaultStringifier.toString(o);
    }

    public String toString() {
      return formatFunctionCall("CombinedStringifier", listPlus((List) stringifiers, defaultStringifier));
    }
  }

  static public class G22LeftArrowScript extends ConceptWithChangeListeners {

    static final public String _fieldOrder = "description text clearedForAutoRun editingText runOnProjectOpen runOrder runCount lastResultByMode compileResultForAutoRun compileResultForSaved";

    public transient FieldVar<String> varDescription_cache;

    public FieldVar<String> varDescription() {
      if (varDescription_cache == null)
        varDescription_cache = varDescription_load();
      return varDescription_cache;
    }

    public FieldVar<String> varDescription_load() {
      return new FieldVar<String>(this, "description", () -> description(), description -> description(description));
    }

    final public G22LeftArrowScript setDescription(String description) {
      return description(description);
    }

    public G22LeftArrowScript description(String description) {
      if (!eq(this.description, description)) {
        this.description = description;
        change();
      }
      return this;
    }

    final public String getDescription() {
      return description();
    }

    public String description() {
      return description;
    }

    public String description;

    public transient FieldVar<String> varText_cache;

    public FieldVar<String> varText() {
      if (varText_cache == null)
        varText_cache = varText_load();
      return varText_cache;
    }

    public FieldVar<String> varText_load() {
      return new FieldVar<String>(this, "text", () -> text(), text -> text(text));
    }

    final public G22LeftArrowScript setText(String text) {
      return text(text);
    }

    public G22LeftArrowScript text(String text) {
      if (!eq(this.text, text)) {
        this.text = text;
        change();
      }
      return this;
    }

    final public String getText() {
      return text();
    }

    public String text() {
      return text;
    }

    public String text;

    public transient FieldVar<ClearForAutoRun<String>> varClearedForAutoRun_cache;

    public FieldVar<ClearForAutoRun<String>> varClearedForAutoRun() {
      if (varClearedForAutoRun_cache == null)
        varClearedForAutoRun_cache = varClearedForAutoRun_load();
      return varClearedForAutoRun_cache;
    }

    public FieldVar<ClearForAutoRun<String>> varClearedForAutoRun_load() {
      return new FieldVar<ClearForAutoRun<String>>(this, "clearedForAutoRun", () -> clearedForAutoRun(), clearedForAutoRun -> clearedForAutoRun(clearedForAutoRun));
    }

    final public G22LeftArrowScript setClearedForAutoRun(ClearForAutoRun<String> clearedForAutoRun) {
      return clearedForAutoRun(clearedForAutoRun);
    }

    public G22LeftArrowScript clearedForAutoRun(ClearForAutoRun<String> clearedForAutoRun) {
      if (!eq(this.clearedForAutoRun, clearedForAutoRun)) {
        this.clearedForAutoRun = clearedForAutoRun;
        change();
      }
      return this;
    }

    final public ClearForAutoRun<String> getClearedForAutoRun() {
      return clearedForAutoRun();
    }

    public ClearForAutoRun<String> clearedForAutoRun() {
      return clearedForAutoRun;
    }

    public ClearForAutoRun<String> clearedForAutoRun;

    public transient FieldVar<String> varEditingText_cache;

    public FieldVar<String> varEditingText() {
      if (varEditingText_cache == null)
        varEditingText_cache = varEditingText_load();
      return varEditingText_cache;
    }

    public FieldVar<String> varEditingText_load() {
      return new FieldVar<String>(this, "editingText", () -> editingText(), editingText -> editingText(editingText));
    }

    final public G22LeftArrowScript setEditingText(String editingText) {
      return editingText(editingText);
    }

    public G22LeftArrowScript editingText(String editingText) {
      if (!eq(this.editingText, editingText)) {
        this.editingText = editingText;
        change();
      }
      return this;
    }

    final public String getEditingText() {
      return editingText();
    }

    public String editingText() {
      return editingText;
    }

    public String editingText;

    public boolean runOnProjectOpen = false;

    public String runOrder;

    public long runCount;

    public Map<G22ScriptMode, WithTimestamp<PersistableOKOrError<G22TypeDesc>>> lastResultByMode;

    @Override
    public void _doneLoading2() {
      cMigrateField(this, "code", "text");
    }

    public String myType() {
      return dropPrefix("G22", shortClassName(this));
    }

    public String toString() {
      return or2(description, myType() + " " + id);
    }

    public void initEditingText() {
      editingText(unnull(or(editingText, text)));
    }

    public void receiveEditingText(String text) {
      editingText(text);
    }

    public String stableText() {
      return text;
    }

    final public void save() {
      completeEdit();
    }

    public void completeEdit() {
      String t = editingText;
      if (t != null) {
        setTextWithHistory(t);
      }
    }

    public void setTextWithHistory(String text) {
      if (eq(this.text, text))
        return;
      text(text);
      saveTextToHistory();
    }

    public String textForEditing() {
      initEditingText();
      return editingText;
    }

    public File historyFile() {
      return fileInConceptsDir("History/" + shortDynName(this) + id + ".history");
    }

    public void saveTextToHistory() {
      saveFieldToHistory("text", text);
    }

    public void saveFieldToHistory(String field, String value) {
      File historyFile = historyFile();
      if (historyFile == null)
        return;
      String contents = value == null ? " empty" : " (" + nLines(value) + ", " + nChars(value) + "):\n" + indentx(value) + "\n" + "\n";
      appendToTextFile(historyFile, "\n===\n" + "Concept ID: " + id + "\n" + "Date: " + dateWithMSUTC() + "\n" + firstToUpper(field) + contents + "===" + "\n");
    }

    public boolean isSaved() {
      return text != null;
    }

    public boolean isSavedDistinctFromAutoRunVersion() {
      return isSaved() && !eq(text, codeForAutoRun());
    }

    public boolean isEditing() {
      return editedText() != null;
    }

    public boolean isClearForAutoRun() {
      return clearedForAutoRun != null;
    }

    public String editedText() {
      return eq(editingText, text) ? null : editingText;
    }

    public String codeForAutoRun() {
      return getVar(clearedForAutoRun());
    }

    public String safestCode() {
      return or(codeForAutoRun(), stableText());
    }

    public void clearForAutoRun() {
      if (!isSaved())
        return;
      String text = text();
      saveFieldToHistory("Auto-runnable code", text);
      clearedForAutoRun(new ClearForAutoRun(text));
    }

    public void forgetAutoRunCode() {
      if (!isClearForAutoRun())
        return;
      saveFieldToHistory("Auto-runnable code", null);
      clearedForAutoRun(null);
      compileResultForAutoRun = null;
    }

    public void forgetCompileResults() {
      compileResultForAutoRun = compileResultForSaved = null;
    }

    public G22Utils g22utils() {
      return assertNotNull("g22utils", main.g22utils(_concepts()));
    }

    public GazelleV_LeftArrowScriptParser makeParser() {
      return g22utils().leftArrowParser();
    }

    public LASCompileResult newCompileResult() {
      return new LASCompileResult();
    }

    transient public LASCompileResult compileResultForAutoRun;

    public LASCompileResult compileForAutoRun() {
      String code = codeForAutoRun();
      if (code == null)
        return null;
      var cr = compileResultForAutoRun;
      if (cr != null && eq(cr.script, code))
        return cr;
      cr = newCompileResult();
      cr.script(code);
      var parser = makeParser();
      cr.parser(parser);
      cr.compile();
      return compileResultForAutoRun = cr;
    }

    transient public LASCompileResult compileResultForSaved;

    public LASCompileResult compileSaved() {
      String code = stableText();
      if (code == null)
        return null;
      var cr = compileResultForSaved;
      if (cr != null && eq(cr.script, code))
        return cr;
      cr = newCompileResult();
      cr.script(code);
      var parser = makeParser();
      cr.parser(parser);
      cr.compile();
      return compileResultForSaved = cr;
    }

    public LASCompileResult safestCompileResult() {
      {
        var __1 = compileForAutoRun();
        if (__1 != null)
          return __1;
      }
      return compileSaved();
    }

    public Object evaluateWithoutTimeout() {
      var cr = safestCompileResult();
      if (cr == null)
        throw fail("Not saved: " + this);
      AutoCloseable __2 = g22utils().enter();
      try {
        return cr.parsedScriptMandatory().get();
      } finally {
        _close(__2);
      }
    }

    public Object evaluateAutoRunWithoutTimeout() {
      var cr = compileForAutoRun();
      if (cr == null)
        throw fail("Not cleared for auto-run: " + this);
      AutoCloseable __3 = g22utils().enter();
      try {
        return cr.parsedScriptMandatory().get();
      } finally {
        _close(__3);
      }
    }

    public String renderRunOnProjectOpenStatus() {
      return runOnProjectOpen ? "Yes" + appendBracketed(appendPrefixIfNempty("prio ", runOrder)) : null;
    }
  }

  static public class AppendableChain<A> extends MinimalChain<A> implements Iterable<A> {

    public MinimalChain<A> last;

    public int size;

    public AppendableChain() {
    }

    public AppendableChain(A element) {
      this.element = element;
      size = 1;
      last = this;
    }

    public AppendableChain(A element, AppendableChain<A> next) {
      this.next = next;
      this.element = element;
      if (next == null)
        return;
      MinimalChain<A> b = new MinimalChain();
      b.element = next.element;
      b.next = next.next;
      this.next = b;
      last = next.last;
      size = next.size + 1;
    }

    public String toString() {
      return str(toList());
    }

    public boolean add(A a) {
      MinimalChain newLast = new MinimalChain(a);
      last.next = newLast;
      last = newLast;
      ++size;
      return true;
    }

    public AppendableChain<A> popFirst() {
      if (next == null)
        return null;
      element = next.element;
      if (last == next)
        last = this;
      next = next.next;
      --size;
      return this;
    }

    public ArrayList<A> toList() {
      ArrayList<A> l = emptyList(size);
      MinimalChain<A> c = this;
      while (c != null) {
        l.add(c.element);
        c = c.next;
      }
      return l;
    }

    public class ACIt extends IterableIterator<A> {

      public MinimalChain<A> c = AppendableChain.this;

      public boolean hasNext() {
        return c != null;
      }

      public A next() {
        var a = c.element;
        c = c.next;
        return a;
      }
    }

    public IterableIterator<A> iterator() {
      return new ACIt();
    }
  }

  static public class HasTokenRangeWithSrc implements IHasTokenRangeWithSrc {

    public TokenRangeWithSrc src;

    public void setTokenRangeWithSrc(TokenRangeWithSrc src) {
      this.src = src;
    }

    public TokenRangeWithSrc tokenRangeWithSrc() {
      return src;
    }
  }

  static public class MultiSleeper extends RestartableCountdown implements ISleeper_v2 {

    public TreeMultiMap<Timestamp, Runnable> entries = new TreeMultiMap();

    public void check() {
      var time = nextWakeUpTime();
      var action = firstValue(entries);
      setTargetTime(time == null ? 0 : time.sysTime(), new Runnable() {

        public void run() {
          try {
            List<Runnable> toCall;
            synchronized (MultiSleeper.this) {
              toCall = entries.get(time);
              entries.remove(time);
            }
            check();
            pcallFAll(toCall);
          } catch (Exception __e) {
            throw rethrow(__e);
          }
        }

        public String toString() {
          return "List<Runnable> toCall;\r\n      synchronized(MultiSleeper.this) {\r\n        toCa...";
        }
      });
    }

    synchronized public void removeEntry(Timestamp targetTime, Runnable action) {
      entries.remove(targetTime, action);
    }

    synchronized public Timestamp nextWakeUpTime() {
      return firstKey(entries);
    }

    public synchronized Sleeping doLater(Timestamp targetTime, Runnable r) {
      if (r == null || targetTime == null)
        return null;
      targetTime = max(targetTime, tsNow());
      entries.put(targetTime, r);
      check();
      return new Sleeping(targetTime, r) {

        public void close() {
          try {
            removeEntry(targetTime, r);
          } catch (Exception __e) {
            throw rethrow(__e);
          }
        }
      };
    }
  }

  static public class ImageSurface_PositionToolTip extends ImageSurfaceMouseHandler {

    public ImageSurface_PositionToolTip(ImageSurface is) {
      if (containsInstance(is.tools, ImageSurface_PositionToolTip.class))
        return;
      register(is);
    }

    final public void mouseDragged(MouseEvent e) {
      mouseMoved(e);
    }

    public void mouseMoved(MouseEvent e) {
      setToolTip(is, getPt(e));
    }
  }

  static public class ListAndIndex<A> implements IFieldsToList {

    static final public String _fieldOrder = "list idx";

    public List<A> list;

    public int idx;

    public ListAndIndex() {
    }

    public ListAndIndex(List<A> list, int idx) {
      this.idx = idx;
      this.list = list;
    }

    public boolean equals(Object o) {
      if (!(o instanceof ListAndIndex))
        return false;
      ListAndIndex __1 = (ListAndIndex) o;
      return eq(list, __1.list) && idx == __1.idx;
    }

    public int hashCode() {
      int h = 276903961;
      h = boostHashCombine(h, _hashCode(list));
      h = boostHashCombine(h, _hashCode(idx));
      return h;
    }

    public Object[] _fieldsToList() {
      return new Object[] { list, idx };
    }

    public boolean atEnd() {
      return idx >= l(list);
    }

    public A get() {
      return _get(list, idx);
    }

    public int size() {
      return l(list);
    }

    public String toString() {
      return subList(list, 0, idx) + ", then " + subList(list, idx);
    }

    public ListAndIndex<A> plus(int ofs) {
      return new ListAndIndex(list, idx + ofs);
    }

    public ListAndIndex<A> minus(int ofs) {
      return new ListAndIndex(list, idx - ofs);
    }

    public List<A> list() {
      return list;
    }

    final public int idx() {
      return index();
    }

    public int index() {
      return idx;
    }

    public ListAndIndex<A> mapIdx(IF1_IntToInt f) {
      return new ListAndIndex<A>(list, f.get(idx));
    }
  }

  static public class MethodMaker {

    public ClassGen cg;

    public MethodGen mg;

    public InstructionList il = new InstructionList();

    public ConstantPoolGen cp;

    public InstructionFactory factory;

    public int frameSize;

    final public MethodMaker setVerboseAdd(boolean verboseAdd) {
      return verboseAdd(verboseAdd);
    }

    public MethodMaker verboseAdd(boolean verboseAdd) {
      this.verboseAdd = verboseAdd;
      return this;
    }

    final public boolean getVerboseAdd() {
      return verboseAdd();
    }

    public boolean verboseAdd() {
      return verboseAdd;
    }

    public boolean verboseAdd = false;

    public boolean classConstantWorkaround = false;

    public MethodMaker(ClassMaker classMaker, Class returnType, String methodName, Class... argumentTypes) {
      this(classMaker.cg, returnType, methodName, argumentTypes);
    }

    public MethodMaker(ClassGen cg, Class returnType, String methodName, Class... argumentTypes) {
      this(cg, Const.ACC_PUBLIC, returnType, methodName, argumentTypes);
    }

    public MethodMaker(ClassGen cg, short modifiers, Class returnType, String methodName, Class... argumentTypes) {
      this.cg = cg;
      cp = cg.getConstantPool();
      factory = new InstructionFactory(cg);
      org.apache.bcel.generic.Type[] argTypes = wrapTypes(argumentTypes);
      mg = new MethodGen(modifiers, wrapType(returnType), argTypes, null, methodName, cg.getClassName(), il, cp);
      frameSize = l(argTypes) + 1;
    }

    static public org.apache.bcel.generic.Type[] wrapTypes(Class[] classes) {
      org.apache.bcel.generic.Type[] types = new org.apache.bcel.generic.Type[l(classes)];
      for (int i = 0; i < l(classes); i++) types[i] = wrapType(classes[i]);
      return types;
    }

    static public org.apache.bcel.generic.Type wrapType(Class c) {
      return classToBCELType(c);
    }

    public int newLocalVar() {
      return frameSize++;
    }

    public MethodMaker newObject(Class c, Class... argTypes) {
      il.append(factory.createNew(className(c)));
      il.append(InstructionConst.DUP);
      Constructor ctor = findConstructor_precise_onTypes(c, argTypes);
      il.append(factory.createInvoke(className(c), "<init>", org.apache.bcel.generic.Type.VOID, wrapTypes(ctor.getParameterTypes()), Const.INVOKESPECIAL));
      return this;
    }

    public MethodMaker dup() {
      il.append(InstructionConst.DUP);
      return this;
    }

    public MethodMaker astore(int var) {
      il.append(new ASTORE(var));
      return this;
    }

    public MethodMaker aload(int var) {
      il.append(new ALOAD(var));
      return this;
    }

    public MethodMaker stringConstant(String s) {
      il.append(new PUSH(cp, s));
      return this;
    }

    public MethodMaker classConstant(Class c) {
      if (classConstantWorkaround) {
        stringConstant(c.getName());
        invokeStatic(Class.class, Class.class, "forName", String.class);
      } else {
        var ldc = new LDC(classRef(c));
        assertEquals("classConstant", ldc.getValue(cp), wrapType(c));
        il.append(ldc);
      }
      return this;
    }

    final public MethodMaker intConst(int i) {
      return intConstant(i);
    }

    public MethodMaker intConstant(int i) {
      if (i >= -1 && i <= 5)
        return add(new ICONST(i));
      if (i == (byte) i)
        return add(new BIPUSH((byte) i));
      if (i == (short) i)
        return add(new SIPUSH((short) i));
      return add(new LDC(cp.addInteger(i)));
    }

    final public MethodMaker doubleConst(double d) {
      return doubleConstant(d);
    }

    public MethodMaker doubleConstant(double d) {
      return add(new LDC2_W(cp.addDouble(d)));
    }

    public MethodMaker boolConstant(boolean b) {
      return intConstant(b ? 1 : 0);
    }

    public MethodMaker invokeVirtual(Class c, Class returnType, String methodName, Class... argTypes) {
      Method m = findNonStaticMethod_precise_onTypes(c, methodName, argTypes);
      if (m == null)
        throw fail("Method not found: " + className(c) + "." + formatFunctionCall(methodName, argTypes) + " returning " + className(returnType));
      il.append(factory.createInvoke(className(c), methodName, wrapType(m.getReturnType()), wrapTypes(m.getParameterTypes()), Const.INVOKEVIRTUAL));
      return this;
    }

    public MethodMaker invokeInterface(Class c, Class returnType, String methodName, Class... argTypes) {
      Method m = mostApplicableMethod_onTypes(filter(nonDefaultInterfaceMethods(c), _m -> _m.getName().equals(methodName)), argTypes);
      if (m == null)
        throw fail("Method not found: " + className(c) + "." + formatFunctionCall(methodName, argTypes) + " returning " + className(returnType));
      il.append(factory.createInvoke(className(c), methodName, wrapType(m.getReturnType()), wrapTypes(m.getParameterTypes()), Const.INVOKEINTERFACE));
      return this;
    }

    public MethodMaker invokeStatic(Class c, Class returnType, String methodName, Class... argTypes) {
      Method m = findMethod_precise_onTypes(c, methodName, argTypes);
      if (m == null)
        throw fail("Method not found: " + className(c) + "." + formatFunctionCall(methodName, argTypes) + " returning " + className(returnType));
      il.append(factory.createInvoke(className(c), methodName, wrapType(m.getReturnType()), wrapTypes(m.getParameterTypes()), Const.INVOKESTATIC));
      return this;
    }

    public MethodMaker areturn() {
      il.append(InstructionConst.ARETURN);
      return this;
    }

    public MethodMaker _return() {
      il.append(InstructionConst.RETURN);
      return this;
    }

    public MethodMaker add(Instruction i) {
      il.append(i);
      if (verboseAdd)
        print("> " + i);
      return this;
    }

    public <A extends Instruction> A addAndReturn(A i) {
      add(i);
      return i;
    }

    public MethodMaker add(BranchInstruction i) {
      il.append(i);
      if (verboseAdd)
        print("> " + i);
      return this;
    }

    public <A extends BranchInstruction> A addAndReturn(A i) {
      add(i);
      return i;
    }

    public void done() {
      mg.stripAttributes(true);
      mg.setMaxStack();
      mg.setMaxLocals();
      cg.addMethod(mg.getMethod());
    }

    public JVMStackCellType convertToObject(JVMStackCellType stackTop) {
      if (stackTop == JVMStackCellType.objValue) {
      } else if (stackTop == JVMStackCellType.intValue)
        invokeStatic(Integer.class, Integer.class, "valueOf", int.class);
      else if (stackTop == JVMStackCellType.doubleValue)
        invokeStatic(Double.class, Double.class, "valueOf", double.class);
      else if (stackTop == JVMStackCellType.none)
        add(new ACONST_NULL());
      else
        throw fail("TODO: add conversion for stack cell type: " + stackTop);
      return JVMStackCellType.objValue;
    }

    public void discardStackTop(JVMStackCellType stackTop) {
      if (stackTop == JVMStackCellType.none) {
      } else if (stackTop == JVMStackCellType.doubleValue || stackTop == JVMStackCellType.longValue)
        add(new POP2());
      else
        add(new POP());
    }

    public int classRef(Class c) {
      return cp.addClass((ObjectType) wrapType(assertNotNull(c)));
    }

    public MethodMaker checkCast(Class c) {
      return add(new CHECKCAST(classRef(c)));
    }

    public MethodMaker loadNull() {
      return add(new ACONST_NULL());
    }

    public InstructionHandle here() {
      return il.append(new NOP());
    }

    public GOTO forwardGoto() {
      return addAndReturn(new GOTO(null));
    }

    public void returnWithType(JVMStackCellType stackTop) {
      if (stackTop == JVMStackCellType.objValue)
        areturn();
      else if (stackTop == JVMStackCellType.intValue)
        add(new IRETURN());
      else if (stackTop == JVMStackCellType.doubleValue)
        add(new DRETURN());
      else if (stackTop == JVMStackCellType.none)
        _return();
      else
        throw fail("TODO: add return for stack cell type: " + stackTop);
    }

    public void getStaticField(String className, String fieldName, Class type) {
      il.append(factory.createGetStatic(className, fieldName, wrapType(type)));
    }
  }

  static public class G22Variable extends ConceptWithChangeListeners implements IPersistenceInfo {

    static final public String _fieldOrder = "name value persistent";

    public String name;

    public transient FieldVar<Object> varValue_cache;

    public FieldVar<Object> varValue() {
      if (varValue_cache == null)
        varValue_cache = varValue_load();
      return varValue_cache;
    }

    public FieldVar<Object> varValue_load() {
      return new FieldVar<Object>(this, "value", () -> value(), value -> value(value));
    }

    final public G22Variable setValue(Object value) {
      return value(value);
    }

    public G22Variable value(Object value) {
      if (!eq(this.value, value)) {
        this.value = value;
        change();
      }
      return this;
    }

    final public Object getValue() {
      return value();
    }

    public Object value() {
      return value;
    }

    volatile public Object value;

    final public G22Variable setPersistent(boolean persistent) {
      return persistent(persistent);
    }

    public G22Variable persistent(boolean persistent) {
      this.persistent = persistent;
      return this;
    }

    final public boolean getPersistent() {
      return persistent();
    }

    public boolean persistent() {
      return persistent;
    }

    public boolean persistent = false;

    public Map _persistenceInfo() {
      return litmap("value", persistent);
    }

    public Object get() {
      return value;
    }

    public void setValueIfNull(Object defaultValue) {
      if (defaultValue != null && value == null)
        value(defaultValue);
    }
  }

  static public class FunctionTimings<A> {

    public Map<A, Average> data = syncMap();

    final public void timeCtex(A function, RunnableWithExceptions r) {
      doCtex(function, r);
    }

    public void doCtex(A function, RunnableWithExceptions r) {
      try {
        if (r == null)
          return;
        long time = nanoTime();
        try {
          r.run();
        } finally {
          time = nanoTime() - time;
          saveTiming(function, time);
        }
      } catch (Exception __e) {
        throw rethrow(__e);
      }
    }

    public <B> B get(A function, IF0<B> f) {
      if (f == null)
        return null;
      Var<B> var = new Var();
      time(function, () -> var.set(f.get()));
      return var.get();
    }

    final public void time(A function, Runnable r) {
      dO(function, r);
    }

    public void dO(A function, Runnable r) {
      if (r == null)
        return;
      long time = nanoTime();
      try {
        r.run();
      } finally {
        time = nanoTime() - time;
        saveTiming(function, time);
      }
    }

    public void saveTiming(A function, long time) {
      Average avg = syncMapGetOrCreate(data, function, () -> new Average());
      avg.add(time);
    }

    public Map<A, Average> get() {
      return cloneMap(data);
    }

    final public void clear() {
      reset();
    }

    public void reset() {
      data.clear();
    }

    final public String toString() {
      return render();
    }

    public String render() {
      return lines(renderedEntries());
    }

    public List<String> renderedEntries() {
      return ciSorted(map(get(), (f, avg) -> functionToString(f) + ": " + n2(iround(nsToMicroseconds(avg.get()))) + " " + microSymbol() + "s (" + n2(iround(avg.n())) + ")"));
    }

    public String toStringSingleLine() {
      return joinWithComma(renderedEntries());
    }

    public String functionToString(A f) {
      return firstToUpper(str(f));
    }
  }

  static public class G22Analyzer extends G22LeftArrowScript {

    public Ref<G22GalleryImage> exampleImage = new Ref();

    @Override
    public GazelleV_LeftArrowScriptParser makeParser() {
      var parser = super.makeParser();
      parser.addVar("image", BufferedImage.class, false);
      parser.addVar("context", G22AnalysisContext.class, false);
      return parser;
    }

    public class CompiledAnalyzer extends LASCompileResult {

      final public CompiledAnalyzer setTimeout(double timeout) {
        return timeout(timeout);
      }

      public CompiledAnalyzer timeout(double timeout) {
        this.timeout = timeout;
        return this;
      }

      final public double getTimeout() {
        return timeout();
      }

      public double timeout() {
        return timeout;
      }

      public double timeout = 10;

      public G22AnalysisContext createAnalysisContext(BufferedImage image) {
        return new G22AnalysisContext(g22utils(), image);
      }

      public Object get_impl(G22AnalysisContext context) {
        VarContext ctx = new VarContext();
        ctx.set("image", context.image);
        ctx.set("context", context);
        return parsedScript.get(ctx);
      }

      public Object get_impl(BufferedImage image) {
        return get_impl(createAnalysisContext(image));
      }

      public Object get(BufferedImage image) {
        return get(createAnalysisContext(image));
      }

      public Object get(G22AnalysisContext context) {
        if (context.analyzerResults.containsKey(analyzer())) {
          Object value = context.analyzerResults.get(analyzer());
          if (value == G22AnalysisContext.calculating)
            throw fail("Recursive call to analyzer " + this);
          return ((OKOrError) value).getMandatory();
        }
        context.analyzerResults.put(analyzer(), G22AnalysisContext.calculating);
        var result = okOrError(() -> {
          if (parsedScript == null)
            rethrow(compileError);
          var image = context.image;
          if (image == null)
            throw fail("Need image");
          return g22utils().evalRegisteredCode(timeout, str(G22Analyzer.this), () -> get_impl(context));
        });
        context.analyzerResults.put(analyzer(), result);
        return result.getMandatory();
      }
    }

    public G22Analyzer analyzer() {
      return this;
    }

    public LASCompileResult newCompileResult() {
      return new CompiledAnalyzer();
    }

    public CompiledAnalyzer compileForAutoRun() {
      return (CompiledAnalyzer) super.compileForAutoRun();
    }
  }

  static public class LASToByteCode implements IFieldsToList {

    public MethodMaker m;

    public LASToByteCode() {
    }

    public LASToByteCode(MethodMaker m) {
      this.m = m;
    }

    public String toString() {
      return shortClassName_dropNumberPrefix(this) + "(" + m + ")";
    }

    public Object[] _fieldsToList() {
      return new Object[] { m };
    }

    public boolean callPing = true;

    final public LASToByteCode setIVarContext(int iVarContext) {
      return iVarContext(iVarContext);
    }

    public LASToByteCode iVarContext(int iVarContext) {
      this.iVarContext = iVarContext;
      return this;
    }

    final public int getIVarContext() {
      return iVarContext();
    }

    public int iVarContext() {
      return iVarContext;
    }

    public int iVarContext = -1;

    public GazelleV_LeftArrowScript.Script returnableScript;

    final public LASToByteCode setPostConversion(IF1<JVMStackCellType, JVMStackCellType> postConversion) {
      return postConversion(postConversion);
    }

    public LASToByteCode postConversion(IF1<JVMStackCellType, JVMStackCellType> postConversion) {
      this.postConversion = postConversion;
      return this;
    }

    final public IF1<JVMStackCellType, JVMStackCellType> getPostConversion() {
      return postConversion();
    }

    public IF1<JVMStackCellType, JVMStackCellType> postConversion() {
      return postConversion;
    }

    public IF1<JVMStackCellType, JVMStackCellType> postConversion;

    public JVMStackCellType compileScript(GazelleV_LeftArrowScript.Script script) {
      returnableScript = script;
      var stackTop = compile(script);
      if (postConversion != null)
        stackTop = postConversion.get(stackTop);
      return stackTop;
    }

    public void compileToObject(GazelleV_LeftArrowScript.Evaluable code) {
      m.convertToObject(compile(code));
    }

    public JVMStackCellType compile(GazelleV_LeftArrowScript.Evaluable code) {
      if (code instanceof GazelleV_LeftArrowScript.Const) {
        Object o = ((GazelleV_LeftArrowScript.Const) code).value;
        if (o == null) {
          m.add(new ACONST_NULL());
          return JVMStackCellType.objValue;
        } else if (o instanceof String) {
          m.stringConstant((String) o);
          return JVMStackCellType.objValue;
        } else if (o instanceof Integer) {
          m.intConstant((Integer) o);
          return JVMStackCellType.intValue;
        } else if (o instanceof Double) {
          m.doubleConstant((Double) o);
          return JVMStackCellType.doubleValue;
        } else if (o instanceof Class) {
          m.classConstant((Class) o);
          return JVMStackCellType.objValue;
        } else if (o instanceof Boolean) {
          m.boolConstant((Boolean) o);
          return JVMStackCellType.intValue;
        } else
          throw fail("Can't compile const value: " + toStringWithClass(o));
      } else if (code instanceof GazelleV_LeftArrowScript.Script) {
        var stackTop = JVMStackCellType.none;
        for (var step : ((GazelleV_LeftArrowScript.Script) code).steps) {
          if (stackTop != JVMStackCellType.none)
            m.add(new POP());
          stackTop = compile(step);
        }
        return stackTop;
      } else if (code instanceof GazelleV_LeftArrowScript.CallMethod) {
        compileToObject(((GazelleV_LeftArrowScript.CallMethod) code).target);
        m.stringConstant(((GazelleV_LeftArrowScript.CallMethod) code).methodName);
        argumentsAsArray(((GazelleV_LeftArrowScript.CallMethod) code).args);
        m.invokeStatic(main.class, Object.class, "call", Object.class, String.class, Object[].class);
        return JVMStackCellType.objValue;
      } else if (code instanceof GazelleV_LeftArrowScript.CallMethodOrGetField) {
        compileToObject(((GazelleV_LeftArrowScript.CallMethodOrGetField) code).target);
        m.stringConstant(((GazelleV_LeftArrowScript.CallMethodOrGetField) code).name);
        m.invokeStatic(main.class, Object.class, "preciseGetOrCallMethod", Object.class, String.class);
        return JVMStackCellType.objValue;
      } else if (code instanceof GazelleV_LeftArrowScript.SetField) {
        compileToObject(((GazelleV_LeftArrowScript.SetField) code).target);
        m.stringConstant(((GazelleV_LeftArrowScript.SetField) code).name);
        compileToObject(((GazelleV_LeftArrowScript.SetField) code).expr);
        m.invokeStatic(main.class, Object.class, "set", Object.class, String.class, Object.class);
        return JVMStackCellType.none;
      } else if (code instanceof GazelleV_LeftArrowScript.NewObject) {
        m.classConstant(((GazelleV_LeftArrowScript.NewObject) code).c);
        argumentsAsArray(((GazelleV_LeftArrowScript.NewObject) code).args);
        m.invokeStatic(main.class, Object.class, "nuObject", Class.class, Object[].class);
        return JVMStackCellType.objValue;
      } else if (code instanceof GazelleV_LeftArrowScript.Assignment) {
        compileToObject(((GazelleV_LeftArrowScript.Assignment) code).expression);
        m.astore(iTemp());
        loadVarContext();
        m.stringConstant(((GazelleV_LeftArrowScript.Assignment) code).var);
        m.aload(iTemp());
        m.invokeVirtual(VarContext.class, void.class, "set", String.class, Object.class);
        m.aload(iTemp());
        return JVMStackCellType.objValue;
      } else if (code instanceof GazelleV_LeftArrowScript.While) {
        var loopStart = m.il.append(new NOP());
        BranchInstruction branch1 = null;
        if (callPing) {
          m.invokeStatic(main.class, boolean.class, "ping");
          branch1 = new IFEQ(null);
          m.add(branch1);
        }
        compileToBool(((GazelleV_LeftArrowScript.While) code).condition);
        var branch2 = new IFEQ(null);
        m.add(branch2);
        m.discardStackTop(compile(((GazelleV_LeftArrowScript.While) code).body));
        m.add(new GOTO(loopStart));
        var loopEnd = m.il.append(new NOP());
        {
          if (branch1 != null)
            branch1.setTarget(loopEnd);
        }
        branch2.setTarget(loopEnd);
        return JVMStackCellType.none;
      } else if (code instanceof GazelleV_LeftArrowScript.IfThen) {
        compileToBool(((GazelleV_LeftArrowScript.IfThen) code).condition);
        var branch1 = new IFEQ(null);
        m.add(branch1);
        var stackTop = compile(((GazelleV_LeftArrowScript.IfThen) code).body);
        if (stackTop == JVMStackCellType.none) {
          branch1.setTarget(m.here());
          return stackTop;
        } else {
          m.convertToObject(stackTop);
          var jumpToEnd = m.forwardGoto();
          branch1.setTarget(m.here());
          m.loadNull();
          jumpToEnd.setTarget(m.here());
          return JVMStackCellType.objValue;
        }
      } else if (code instanceof GazelleV_LeftArrowScript.GetVar) {
        return compileGetVar((GazelleV_LeftArrowScript.GetVar) code);
      } else if (code instanceof GazelleV_LeftArrowScript.ReturnFromScript) {
        if (((GazelleV_LeftArrowScript.ReturnFromScript) code).script != returnableScript)
          throw fail("Can only return from current script");
        var stackTop = compile(((GazelleV_LeftArrowScript.ReturnFromScript) code).value);
        if (postConversion != null)
          stackTop = postConversion.get(stackTop);
        m.returnWithType(stackTop);
        return JVMStackCellType.none;
      }
      throw fail("Can't compile yet: " + className(code));
    }

    public void argumentsAsArray(GazelleV_LeftArrowScript.Evaluable[] args) {
      int n = l(args);
      m.intConst(n);
      m.add(new ANEWARRAY(m.classRef(Object.class)));
      for (int iArg = 0; iArg < n; iArg++) {
        m.dup();
        m.intConst(iArg);
        compileToObject(args[iArg]);
        m.add(new AASTORE());
      }
    }

    public void loadVarContext() {
      assertTrue("Need VarContext", iVarContext >= 0);
      m.aload(iVarContext);
    }

    public Integer iTemp_cache;

    public int iTemp() {
      if (iTemp_cache == null)
        iTemp_cache = iTemp_load();
      return iTemp_cache;
    }

    public Integer iTemp_load() {
      return m.newLocalVar();
    }

    public void compileToBool(GazelleV_LeftArrowScript.Evaluable condition) {
      var stackTop = compile(condition);
      if (stackTop == JVMStackCellType.objValue) {
        m.checkCast(Boolean.class);
        m.invokeVirtual(Boolean.class, boolean.class, "booleanValue");
      } else if (stackTop == JVMStackCellType.intValue) {
      } else
        throw fail("Can't convert to bool: " + stackTop);
    }

    public JVMStackCellType compileGetVar(GazelleV_LeftArrowScript.GetVar code) {
      loadVarContext();
      m.stringConstant(code.var);
      m.invokeVirtual(VarContext.class, Object.class, "get", String.class);
      return JVMStackCellType.objValue;
    }
  }

  static public class LineAndColumn implements IFieldsToList {

    static final public String _fieldOrder = "line col getLineText";

    public int line;

    public int col;

    public LineAndColumn() {
    }

    public LineAndColumn(int line, int col) {
      this.col = col;
      this.line = line;
    }

    public boolean equals(Object o) {
      if (!(o instanceof LineAndColumn))
        return false;
      LineAndColumn __1 = (LineAndColumn) o;
      return line == __1.line && col == __1.col;
    }

    public int hashCode() {
      int h = -1128952231;
      h = boostHashCombine(h, _hashCode(line));
      h = boostHashCombine(h, _hashCode(col));
      return h;
    }

    public Object[] _fieldsToList() {
      return new Object[] { line, col };
    }

    transient public IF1<Integer, String> getLineText;

    public String getLineText(int line) {
      return getLineText != null ? getLineText.get(line) : getLineText_base(line);
    }

    final public String getLineText_fallback(IF1<Integer, String> _f, int line) {
      return _f != null ? _f.get(line) : getLineText_base(line);
    }

    public String getLineText_base(int line) {
      return null;
    }

    public String toString() {
      return "Line " + n2(line) + ", col " + n2(col);
    }
  }

  static public class FailedRule extends RuleWithParams {

    public List<Exp> satisfiedConditions;

    public Exp remainingCondition;

    public FailedRule() {
    }

    public FailedRule(IfThen rule, VarMatches matches, Exp remainingCondition) {
      this.remainingCondition = remainingCondition;
      this.matches = matches;
      this.rule = rule;
    }

    public FailedRule(IfThen rule, VarMatches matches, List<Exp> satisfiedConditions, Exp remainingCondition) {
      this.remainingCondition = remainingCondition;
      this.satisfiedConditions = satisfiedConditions;
      this.matches = matches;
      this.rule = rule;
    }
  }

  static public class RuleWithParams implements IFieldsToList {

    static final public String _fieldOrder = "rule matches";

    public IfThen rule;

    public VarMatches matches;

    public RuleWithParams() {
    }

    public RuleWithParams(IfThen rule, VarMatches matches) {
      this.matches = matches;
      this.rule = rule;
    }

    public String toString() {
      return shortClassName_dropNumberPrefix(this) + "(" + rule + ", " + matches + ")";
    }

    public boolean equals(Object o) {
      if (!(o instanceof RuleWithParams))
        return false;
      RuleWithParams __7 = (RuleWithParams) o;
      return eq(rule, __7.rule) && eq(matches, __7.matches);
    }

    public int hashCode() {
      int h = 1254104616;
      h = boostHashCombine(h, _hashCode(rule));
      h = boostHashCombine(h, _hashCode(matches));
      return h;
    }

    public Object[] _fieldsToList() {
      return new Object[] { rule, matches };
    }

    public String ruleID() {
      return rule.globalID;
    }
  }

  static public class IfThen implements IFieldsToList {

    static final public String _fieldOrder = "in out globalID options originalText";

    public Exp in;

    public Exp out;

    public IfThen() {
    }

    public IfThen(Exp in, Exp out) {
      this.out = out;
      this.in = in;
    }

    public boolean equals(Object o) {
      if (!(o instanceof IfThen))
        return false;
      IfThen __8 = (IfThen) o;
      return eq(in, __8.in) && eq(out, __8.out);
    }

    public int hashCode() {
      int h = -2108234502;
      h = boostHashCombine(h, _hashCode(in));
      h = boostHashCombine(h, _hashCode(out));
      return h;
    }

    public Object[] _fieldsToList() {
      return new Object[] { in, out };
    }

    public String globalID;

    public Set<String> options;

    public String originalText;

    public String text() {
      Collection<String> opt = options;
      if (nempty(globalID))
        opt = concatLists(ll("id: " + globalID), opt);
      return (nempty(opt) ? "[" + joinWithComma(opt) + "] " : "") + (in == null ? "" : in.text() + "\n  => ") + nlLogic_text(out);
    }

    public String toString() {
      return text();
    }
  }

  abstract static public class Exp {

    abstract public String text();

    public String toString() {
      return text();
    }
  }

  static public class Func extends Exp implements IFieldsToList {

    public String name;

    public Exp arg;

    public Func() {
    }

    public Func(String name, Exp arg) {
      this.arg = arg;
      this.name = name;
    }

    public boolean equals(Object o) {
      if (!(o instanceof Func))
        return false;
      Func __0 = (Func) o;
      return eq(name, __0.name) && eq(arg, __0.arg);
    }

    public int hashCode() {
      int h = 2201316;
      h = boostHashCombine(h, _hashCode(name));
      h = boostHashCombine(h, _hashCode(arg));
      return h;
    }

    public Object[] _fieldsToList() {
      return new Object[] { name, arg };
    }

    public List<String> options;

    public Func(String name, List<String> options, Exp arg) {
      this.arg = arg;
      this.options = options;
      this.name = name;
    }

    public String text() {
      return name + (empty(options) ? "" : "[" + joinWithComma(options) + "]") + "(" + arg.text() + ")";
    }

    public String argText() {
      return nlLogic_text(arg);
    }
  }

  static public class And extends Exp implements IFieldsToList {

    public Exp a;

    public Exp b;

    public And() {
    }

    public And(Exp a, Exp b) {
      this.b = b;
      this.a = a;
    }

    public boolean equals(Object o) {
      if (!(o instanceof And))
        return false;
      And __1 = (And) o;
      return eq(a, __1.a) && eq(b, __1.b);
    }

    public int hashCode() {
      int h = 65975;
      h = boostHashCombine(h, _hashCode(a));
      h = boostHashCombine(h, _hashCode(b));
      return h;
    }

    public Object[] _fieldsToList() {
      return new Object[] { a, b };
    }

    public String text() {
      return a.text() + "\n  && " + b.text();
    }
  }

  static public class ExpNot extends Exp implements IFieldsToList {

    public Exp a;

    public ExpNot() {
    }

    public ExpNot(Exp a) {
      this.a = a;
    }

    public boolean equals(Object o) {
      if (!(o instanceof ExpNot))
        return false;
      ExpNot __2 = (ExpNot) o;
      return eq(a, __2.a);
    }

    public int hashCode() {
      int h = 2089649046;
      h = boostHashCombine(h, _hashCode(a));
      return h;
    }

    public Object[] _fieldsToList() {
      return new Object[] { a };
    }

    public String text() {
      return "!" + a.text();
    }
  }

  abstract static public class Literal extends Exp {
  }

  static public class Sentence extends Literal implements IFieldsToList {

    public List<String> tok;

    public Sentence() {
    }

    public Sentence(List<String> tok) {
      this.tok = tok;
    }

    public boolean equals(Object o) {
      if (!(o instanceof Sentence))
        return false;
      Sentence __3 = (Sentence) o;
      return eq(tok, __3.tok);
    }

    public int hashCode() {
      int h = 1327381123;
      h = boostHashCombine(h, _hashCode(tok));
      return h;
    }

    public Object[] _fieldsToList() {
      return new Object[] { tok };
    }

    public String text() {
      return join(tok);
    }
  }

  static public class Sentence2 extends Literal implements IFieldsToList {

    public String text;

    public Sentence2() {
    }

    public Sentence2(String text) {
      this.text = text;
    }

    public boolean equals(Object o) {
      if (!(o instanceof Sentence2))
        return false;
      Sentence2 __4 = (Sentence2) o;
      return eq(text, __4.text);
    }

    public int hashCode() {
      int h = -1800858097;
      h = boostHashCombine(h, _hashCode(text));
      return h;
    }

    public Object[] _fieldsToList() {
      return new Object[] { text };
    }

    public String text() {
      return text;
    }
  }

  static public class Eq extends Exp implements IFieldsToList {

    public Exp left;

    public Exp right;

    public Eq() {
    }

    public Eq(Exp left, Exp right) {
      this.right = right;
      this.left = left;
    }

    public boolean equals(Object o) {
      if (!(o instanceof Eq))
        return false;
      Eq __5 = (Eq) o;
      return eq(left, __5.left) && eq(right, __5.right);
    }

    public int hashCode() {
      int h = 2252;
      h = boostHashCombine(h, _hashCode(left));
      h = boostHashCombine(h, _hashCode(right));
      return h;
    }

    public Object[] _fieldsToList() {
      return new Object[] { left, right };
    }

    public String text() {
      return left.text() + " = " + right.text();
    }
  }

  static public class G22AutoStarter extends MetaWithChangeListeners implements AutoCloseable, IFieldsToList {

    public G22Utils g22utils;

    public G22AutoStarter() {
    }

    public G22AutoStarter(G22Utils g22utils) {
      this.g22utils = g22utils;
    }

    public String toString() {
      return shortClassName_dropNumberPrefix(this) + "(" + g22utils + ")";
    }

    public Object[] _fieldsToList() {
      return new Object[] { g22utils };
    }

    public transient FieldVar<Boolean> varEnabled_cache;

    public FieldVar<Boolean> varEnabled() {
      if (varEnabled_cache == null)
        varEnabled_cache = varEnabled_load();
      return varEnabled_cache;
    }

    public FieldVar<Boolean> varEnabled_load() {
      return new FieldVar<Boolean>(this, "enabled", () -> enabled(), enabled -> enabled(enabled));
    }

    final public G22AutoStarter setEnabled(boolean enabled) {
      return enabled(enabled);
    }

    public G22AutoStarter enabled(boolean enabled) {
      if (!eq(this.enabled, enabled)) {
        this.enabled = enabled;
        change();
      }
      return this;
    }

    final public boolean getEnabled() {
      return enabled();
    }

    public boolean enabled() {
      return enabled;
    }

    volatile public boolean enabled = true;

    public transient FieldVar<Integer> varInitialDelay_cache;

    public FieldVar<Integer> varInitialDelay() {
      if (varInitialDelay_cache == null)
        varInitialDelay_cache = varInitialDelay_load();
      return varInitialDelay_cache;
    }

    public FieldVar<Integer> varInitialDelay_load() {
      return new FieldVar<Integer>(this, "initialDelay", () -> initialDelay(), initialDelay -> initialDelay(initialDelay));
    }

    final public G22AutoStarter setInitialDelay(int initialDelay) {
      return initialDelay(initialDelay);
    }

    public G22AutoStarter initialDelay(int initialDelay) {
      if (!eq(this.initialDelay, initialDelay)) {
        this.initialDelay = initialDelay;
        change();
      }
      return this;
    }

    final public int getInitialDelay() {
      return initialDelay();
    }

    public int initialDelay() {
      return initialDelay;
    }

    volatile public int initialDelay = 1;

    public transient FieldVar<Integer> varNScriptsRun_cache;

    public FieldVar<Integer> varNScriptsRun() {
      if (varNScriptsRun_cache == null)
        varNScriptsRun_cache = varNScriptsRun_load();
      return varNScriptsRun_cache;
    }

    public FieldVar<Integer> varNScriptsRun_load() {
      return new FieldVar<Integer>(this, "nScriptsRun", () -> nScriptsRun(), nScriptsRun -> nScriptsRun(nScriptsRun));
    }

    final public G22AutoStarter setNScriptsRun(int nScriptsRun) {
      return nScriptsRun(nScriptsRun);
    }

    public G22AutoStarter nScriptsRun(int nScriptsRun) {
      if (!eq(this.nScriptsRun, nScriptsRun)) {
        this.nScriptsRun = nScriptsRun;
        change();
      }
      return this;
    }

    final public int getNScriptsRun() {
      return nScriptsRun();
    }

    public int nScriptsRun() {
      return nScriptsRun;
    }

    volatile public int nScriptsRun;

    public transient FieldVar<AutoStartScript> varCurrentScript_cache;

    public FieldVar<AutoStartScript> varCurrentScript() {
      if (varCurrentScript_cache == null)
        varCurrentScript_cache = varCurrentScript_load();
      return varCurrentScript_cache;
    }

    public FieldVar<AutoStartScript> varCurrentScript_load() {
      return new FieldVar<AutoStartScript>(this, "currentScript", () -> currentScript(), currentScript -> currentScript(currentScript));
    }

    final public G22AutoStarter setCurrentScript(AutoStartScript currentScript) {
      return currentScript(currentScript);
    }

    public G22AutoStarter currentScript(AutoStartScript currentScript) {
      if (!eq(this.currentScript, currentScript)) {
        this.currentScript = currentScript;
        change();
      }
      return this;
    }

    final public AutoStartScript getCurrentScript() {
      return currentScript();
    }

    public AutoStartScript currentScript() {
      return currentScript;
    }

    volatile public AutoStartScript currentScript;

    public Flag started = new Flag();

    public Flag waited = new Flag();

    public Flag ctrlPressed = new Flag();

    public List<AutoStartScript> scripts = syncL();

    public AutoCloseable ctrlListener;

    public ReliableSingleThread rst = rst(() -> _run());

    public class AutoStartScript extends RunResultWithTimestamps implements IFieldsToList {

      public G22LeftArrowScript script;

      public AutoStartScript() {
      }

      public AutoStartScript(G22LeftArrowScript script) {
        this.script = script;
      }

      public String toString() {
        return shortClassName_dropNumberPrefix(this) + "(" + script + ")";
      }

      public Object[] _fieldsToList() {
        return new Object[] { script };
      }

      public void run() {
        try {
          LASCompileResult cr = script.compileForAutoRun();
          if (cr == null)
            cr = script.compileSaved();
          var _cr_2 = cr;
          run(() -> {
            G22AutoStarter.this.change();
            if (_cr_2 == null)
              throw fail("Script is not saved: " + script);
            var parsed = _cr_2.parsedScriptMandatory();
            return parsed.get();
          });
        } catch (Exception __e) {
          throw rethrow(__e);
        }
      }
    }

    public void init() {
      if (ctrlListener != null)
        return;
      scripts.clear();
      var scripts = conceptsWhere(g22utils.concepts, G22LeftArrowScript.class, "runOnProjectOpen", true);
      var sorted = sortByCalculatedFieldAlphaNumIC(scripts, s -> s.runOrder);
      for (var script : sorted) this.scripts.add(new AutoStartScript(script));
      change();
      ctrlListener = tempAddGlobalCtrlKeyListener(b -> {
        if (b) {
          ctrlPressed.raise();
          cancel();
        }
      });
    }

    public void start() {
      print("G22AutoStarter: Start");
      if (enabled)
        rst.get();
    }

    public void _run() {
      if (!enabled)
        return;
      AutoCloseable __1 = g22utils.backgroundProcessesUI.tempAdd("Auto-Start Scripts");
      try {
        if (started.raise())
          change();
        if (!waited.get()) {
          print("G22AutoStarter: Sleeping");
          while (initialDelay > 0) {
            sleepSeconds(1);
            initialDelay(initialDelay - 1);
          }
          waited.raise();
          change();
          print("G22AutoStarter: Slept");
        }
        while (enabled && !done()) {
          var script = scripts.get(nScriptsRun);
          currentScript(script);
          change();
          script.run();
          nScriptsRun(nScriptsRun + 1);
          currentScript(null);
          change();
        }
        change();
        close();
      } finally {
        _close(__1);
      }
    }

    public boolean done() {
      return nScriptsRun >= l(scripts);
    }

    public void cancel() {
      setEnabled(false);
    }

    public boolean canResume() {
      return !done() && !enabled;
    }

    public void resume() {
      if (done()) {
        infoBox("Nothing to resume - auto-start is done");
        return;
      }
      if (enabled) {
        infoBox("Already running");
        return;
      }
      infoBox("Resuming auto-start");
      setEnabled(true);
      rst.get();
    }

    public String status() {
      return !enabled ? ctrlPressed.get() ? "Cancelled due to ctrl key" : "Cancelled" : done() ? "Done" : waited.get() ? "Started" : started.get() ? "Pre-start wait (" + formatDouble1(initialDelay) + "s)" : "Not started";
    }

    public String stats() {
      return status() + ". " + scriptsRunStats();
    }

    public String scriptsRunStats() {
      return "Scripts run: " + nScriptsRun() + "/" + l(scripts);
    }

    public String currentScriptStats() {
      var s = currentScript;
      if (s == null)
        return "";
      return "Running: " + s.script;
    }

    public void close() {
      try {
        if (ctrlListener != null) {
          {
            cleanUp(ctrlListener);
            ctrlListener = null;
          }
          change();
        }
      } catch (Exception __e) {
        throw rethrow(__e);
      }
    }

    public void waitUntilDone() {
      waitForVarPredicate(varNScriptsRun(), () -> done());
    }

    public boolean ctrlEnabled() {
      return ctrlListener != null;
    }
  }

  static public class JLeftArrowScriptIDE extends MetaWithChangeListeners implements Swingable {

    final public JLeftArrowScriptIDE setLvScript(SimpleLiveValue<String> lvScript) {
      return lvScript(lvScript);
    }

    public JLeftArrowScriptIDE lvScript(SimpleLiveValue<String> lvScript) {
      this.lvScript = lvScript;
      return this;
    }

    final public SimpleLiveValue<String> getLvScript() {
      return lvScript();
    }

    public SimpleLiveValue<String> lvScript() {
      return lvScript;
    }

    public SimpleLiveValue<String> lvScript = stringLiveValue();

    final public JLeftArrowScriptIDE setSectionTitle(String sectionTitle) {
      return sectionTitle(sectionTitle);
    }

    public JLeftArrowScriptIDE sectionTitle(String sectionTitle) {
      this.sectionTitle = sectionTitle;
      return this;
    }

    final public String getSectionTitle() {
      return sectionTitle();
    }

    public String sectionTitle() {
      return sectionTitle;
    }

    public String sectionTitle = "Left arrow script";

    final public JLeftArrowScriptIDE setWithResultPanel(boolean withResultPanel) {
      return withResultPanel(withResultPanel);
    }

    public JLeftArrowScriptIDE withResultPanel(boolean withResultPanel) {
      this.withResultPanel = withResultPanel;
      return this;
    }

    final public boolean getWithResultPanel() {
      return withResultPanel();
    }

    public boolean withResultPanel() {
      return withResultPanel;
    }

    public boolean withResultPanel = true;

    final public JLeftArrowScriptIDE setCompileDelay(double compileDelay) {
      return compileDelay(compileDelay);
    }

    public JLeftArrowScriptIDE compileDelay(double compileDelay) {
      this.compileDelay = compileDelay;
      return this;
    }

    final public double getCompileDelay() {
      return compileDelay();
    }

    public double compileDelay() {
      return compileDelay;
    }

    public double compileDelay = 0.1;

    static public String helpText = "Gazelle 22 \"Left Arrow Script\"\r\n------------------------------\r\n\r\n\"Left arrow script\" is one of Gazelle 22's two scripting languages. It is the powerful one of the two. It can do anything Java can do except for defining classes or lambdas.\r\n\r\n-Usually, you write one command per line\r\n-Each command contains at most one action and at most one assignment\r\n-The language is case-sensitive\r\n-You can add comments like in Java with /* */ or //\r\n-You can write multiple commands in one line by separating them with a semicolon\r\n-Arguments to functions are separated by spaces\r\n-You can use integer and string literals like in Java\r\n-You can use true, false and null\r\n\r\nIt's called \"left arrow script\" because the left arrow (variable assignment) is its only actual operator (not counting ; and {}).\r\n\r\n\r\nOperations\r\n----------\r\n\r\nYou can call any global function defined in Gazelle. Example:\r\n\r\n  infoBox \"hello\"   // show a popup with the text \"hello\"\r\n  \r\nYou can assign the result of a function call to a variable:\r\n\r\n  time <- tsNow     // get current time as a Timestamp object\r\n  infoBox time      // show as popup\r\n  \r\nNote that this script requires 2 lines because only one operation is allowed per command.\r\n  \r\nVariables can be overwritten and don't have to be declared.\r\n\r\n\r\nCreating objects\r\n----------------\r\n\r\nYou can create an instance of any Java class and call methods on the object:\r\n\r\n  list <- new ArrayList\r\n  list add \"hello\"\r\n  list add \"world\"\r\n  infoBox list       // shows [hello, world]\r\n  \r\n(Currently you can also say \"list <- ArrayList\", but this is ambiguous and may be removed in a future version.)\r\n  \r\nYou can pass parameters to the constructor:\r\n\r\n  pair <- new Pair \"hello\" \"world\"\r\n  infoBox pair      // shows <hello, world>\r\n  \r\n\r\nJava operators (+, * etc)\r\n-------------------------\r\n  \r\nJava operators can't be used directly but we have functions that do the same thing (if we don't, we'll add them):\r\n\r\n  x <- plus 1 2\r\n  infoBox x\r\n\r\n\r\nFunction definitions\r\n--------------------\r\n\r\nYou can define functions in your script, with arguments. The function can return a value (which is the result of the last command in the function).\r\n\r\n  def doubleMe x { mul x 2 }\r\n\r\n  x <- doubleMe 5\r\n  infoBox x        // shows 10\r\n";

    public transient FieldVar<LASCompileResult> varCompileResult_cache;

    public FieldVar<LASCompileResult> varCompileResult() {
      if (varCompileResult_cache == null)
        varCompileResult_cache = varCompileResult_load();
      return varCompileResult_cache;
    }

    public FieldVar<LASCompileResult> varCompileResult_load() {
      return new FieldVar<LASCompileResult>(this, "compileResult", () -> compileResult(), compileResult -> compileResult(compileResult));
    }

    final public JLeftArrowScriptIDE setCompileResult(LASCompileResult compileResult) {
      return compileResult(compileResult);
    }

    public JLeftArrowScriptIDE compileResult(LASCompileResult compileResult) {
      if (!eq(this.compileResult, compileResult)) {
        this.compileResult = compileResult;
        change();
      }
      return this;
    }

    final public LASCompileResult getCompileResult() {
      return compileResult();
    }

    public LASCompileResult compileResult() {
      return compileResult;
    }

    transient public LASCompileResult compileResult;

    transient public RSyntaxTextAreaWithSearch taScript;

    transient public RSTADummyParser dummyParser = new RSTADummyParser();

    transient public Q compileQ = new Q();

    final public JPanel getButtons() {
      return buttons();
    }

    public JPanel buttons() {
      return buttons;
    }

    transient public JPanel buttons = jline();

    transient public JButton btnRun;

    transient public CollapsibleLeftPanel collapsibleResultPanel;

    transient public G22ScriptResultPanel resultPanel;

    transient public JPopDownButton popDownButton;

    transient public LeftArrowCompletionProvider completionProvider;

    final public JLeftArrowScriptIDE setG22utils(G22Utils g22utils) {
      return g22utils(g22utils);
    }

    public JLeftArrowScriptIDE g22utils(G22Utils g22utils) {
      this.g22utils = g22utils;
      return this;
    }

    final public G22Utils getG22utils() {
      return g22utils();
    }

    public G22Utils g22utils() {
      return g22utils;
    }

    transient public G22Utils g22utils;

    final public JLeftArrowScriptIDE setScriptTimeout(double scriptTimeout) {
      return scriptTimeout(scriptTimeout);
    }

    public JLeftArrowScriptIDE scriptTimeout(double scriptTimeout) {
      this.scriptTimeout = scriptTimeout;
      return this;
    }

    final public double getScriptTimeout() {
      return scriptTimeout();
    }

    public double scriptTimeout() {
      return scriptTimeout;
    }

    public double scriptTimeout = 10.0;

    final public JLeftArrowScriptIDE setShowTitle(boolean showTitle) {
      return showTitle(showTitle);
    }

    public JLeftArrowScriptIDE showTitle(boolean showTitle) {
      this.showTitle = showTitle;
      return this;
    }

    final public boolean getShowTitle() {
      return showTitle();
    }

    public boolean showTitle() {
      return showTitle;
    }

    transient public boolean showTitle = true;

    transient public IF0<GazelleV_LeftArrowScriptParser> makeParser;

    public GazelleV_LeftArrowScriptParser makeParser() {
      return makeParser != null ? makeParser.get() : makeParser_base();
    }

    final public GazelleV_LeftArrowScriptParser makeParser_fallback(IF0<GazelleV_LeftArrowScriptParser> _f) {
      return _f != null ? _f.get() : makeParser_base();
    }

    public GazelleV_LeftArrowScriptParser makeParser_base() {
      return g22utils.leftArrowParser();
    }

    public class LeftArrowCompletionProvider extends DefaultCompletionProvider {

      @Override
      public List<Completion> getCompletionsImpl(JTextComponent comp) {
        try {
          String text = getText(comp);
          GazelleV_LeftArrowScriptParser parser = makeParser2();
          LeftArrowScriptAutoCompleter completer = new LeftArrowScriptAutoCompleter(g22utils, parser);
          enableScaffolding(completer);
          completer.seek(text, getCaretPosition(comp));
          return map(completer.searcher().withScores(), completion -> {
            BasicCompletion c = new BasicCompletion(this, completion.get());
            c.setRelevance((int) completion.score());
            return c;
          });
        } catch (Throwable e) {
          printStackTrace(e);
          return ll();
        }
      }
    }

    public JComponent wrapStatusLabel(JComponent lbl) {
      onLeftClick(lbl, () -> {
        LineAndColumn lineAndCol = compileResult == null ? null : compileResult.errorLineAndCol();
        if (lineAndCol != null) {
          moveCaretToLineAndCol(textArea(), lineAndCol);
          focus(textArea());
        }
      });
      popDownButton = swing(() -> new JPopDownButton("Help"));
      popDownButton.onFillingMenu(menu -> addMenuItems(menu, "Show Scripting Help", runnableThread(new Runnable() {

        public void run() {
          try {
            showTextWordWrapped("Gazelle 'Left arrow script' Help", helpText);
          } catch (Exception __e) {
            throw rethrow(__e);
          }
        }

        public String toString() {
          return "showTextWordWrapped(\"Gazelle 'Left arrow script' Help\", helpText)";
        }
      }), "Show Global Class Names", runnableThread(new Runnable() {

        public void run() {
          try {
            showGlobalClassNames();
          } catch (Exception __e) {
            throw rethrow(__e);
          }
        }

        public String toString() {
          return "showGlobalClassNames();";
        }
      }), "Convert to Java", runnableThread(new Runnable() {

        public void run() {
          try {
            convertToJava();
          } catch (Exception __e) {
            throw rethrow(__e);
          }
        }

        public String toString() {
          return "convertToJava();";
        }
      })));
      return centerAndEastWithMargin(jBorderlessHigherScrollPane(lbl), jfullcenter(buttons));
    }

    public transient JComponent visualize_cache;

    public JComponent visualize() {
      if (visualize_cache == null)
        visualize_cache = visualize_load();
      return visualize_cache;
    }

    public JComponent visualize_load() {
      return markVisualizer(this, visualize_impl());
    }

    public JComponent visualize_impl() {
      return swing(() -> {
        taScript = g22utils.newSyntaxTextArea(__1 -> wrapStatusLabel(__1));
        bindTextComponentToLiveValue_bothWays_noInitialUndo(textArea(), lvScript);
        dummyParser.install(textArea());
        onCtrlEnter(textArea(), runnableThread(new Runnable() {

          public void run() {
            try {
              runScript();
            } catch (Exception __e) {
              throw rethrow(__e);
            }
          }

          public String toString() {
            return "runScript();";
          }
        }));
        awtCalcEvery(textArea(), compileDelay, () -> compileQ.add(new Runnable() {

          public void run() {
            try {
              compile();
            } catch (Exception __e) {
              throw rethrow(__e);
            }
          }

          public String toString() {
            return "compile();";
          }
        }));
        installCompletionProvider(completionProvider = new LeftArrowCompletionProvider(), textArea());
        JComponent vis = taScript.visualize();
        if (showTitle)
          vis = jCenteredSection(sectionTitle, vis);
        vis = wrapSection(vis);
        addAll(buttons, btnRun = jbutton("Run", runnableThread(new Runnable() {

          public void run() {
            try {
              runScript();
            } catch (Exception __e) {
              throw rethrow(__e);
            }
          }

          public String toString() {
            return "runScript();";
          }
        })), popDownButton);
        if (withResultPanel) {
          resultPanel = new G22ScriptResultPanel();
          collapsibleResultPanel = new CollapsibleLeftPanel(false, "Output", resultPanel.visualize(), vis);
          collapsibleResultPanel.sidePanelMargins = c -> withTopAndLeftMargin(c);
          return collapsibleResultPanel.visualize();
        } else
          return vis;
      });
    }

    transient public IF1<JComponent, JComponent> wrapSection;

    public JComponent wrapSection(JComponent c) {
      return wrapSection != null ? wrapSection.get(c) : wrapSection_base(c);
    }

    final public JComponent wrapSection_fallback(IF1<JComponent, JComponent> _f, JComponent c) {
      return _f != null ? _f.get(c) : wrapSection_base(c);
    }

    public JComponent wrapSection_base(JComponent c) {
      return c;
    }

    public RSyntaxTextArea textArea() {
      if (taScript == null)
        visualize();
      return taScript.textArea();
    }

    public void setText(String text) {
      main.setText(textArea(), text);
    }

    public boolean visible() {
      return isShowing(textArea());
    }

    public void compile() {
      var script = lvScript.get();
      var result = compileResult;
      if (result == null || !eq(result.script, script)) {
        result = newCompileResult();
        result.script = script;
        result.makeParser = () -> makeParser();
        result.compile();
        compileResult(result);
        showStatus(str(compileResult));
        updateRunButtonState();
        List<RSTADummyParser.Error> errors = new ArrayList();
        if (result.compileError != null) {
          LineAndColumn lineAndCol = result.errorLineAndCol();
          if (lineAndCol != null)
            errors.add(new RSTADummyParser.Error().msg(result.errorToString()).start(lineAndCol).end(new LineAndColumn(lineAndCol.line + 1, 1)));
        }
        dummyParser.setErrors(result.script, errors, textArea());
      }
    }

    public void updateRunButtonState() {
      setEnabled(btnRun, runButtonShouldBeEnabled());
    }

    transient public IF0<Boolean> runButtonShouldBeEnabled;

    public boolean runButtonShouldBeEnabled() {
      return runButtonShouldBeEnabled != null ? runButtonShouldBeEnabled.get() : runButtonShouldBeEnabled_base();
    }

    final public boolean runButtonShouldBeEnabled_fallback(IF0<Boolean> _f) {
      return _f != null ? _f.get() : runButtonShouldBeEnabled_base();
    }

    public boolean runButtonShouldBeEnabled_base() {
      return compileResult != null && compileResult.runnable();
    }

    public LASCompileResult freshCompileResult() {
      runInQAndWait(compileQ, new Runnable() {

        public void run() {
          try {
            compile();
          } catch (Exception __e) {
            throw rethrow(__e);
          }
        }

        public String toString() {
          return "compile();";
        }
      });
      return compileResult;
    }

    public GazelleV_LeftArrowScript.Script parsedScript() {
      return freshCompileResult().parsedScript;
    }

    transient public Runnable runScript;

    public void runScript() {
      if (runScript != null)
        runScript.run();
      else
        runScript_base();
    }

    final public void runScript_fallback(Runnable _f) {
      if (_f != null)
        _f.run();
      else
        runScript_base();
    }

    public void runScript_base() {
      var result = freshCompileResult();
      if (result.parsedScript != null) {
        var value = runResultWithTimestamps(() -> callCompiledObjectWithTimeout(result.parsedScript));
        showScriptResult(value);
      }
    }

    public void showScriptResult(RunResultWithTimestamps result) {
      resultPanel.logView.setText(str(result.printOutput()));
      showScriptResult(result.result());
    }

    public void showScriptResult(OKOrError result) {
      if (result.isOK()) {
        setStatus(shorten(g22utils.stringify(result.get())));
        var objVisualizer = new G22JavaObjectVisualizer(g22utils, result.get());
        if (collapsibleResultPanel != null)
          objVisualizer.withTypeAndTime(false);
        resultPanel.scpResult.set(objVisualizer);
        if (collapsibleResultPanel != null)
          collapsibleResultPanel.sidePanelName("Output" + appendBracketed(objVisualizer.objectInfos()));
      } else {
        setStatus(exceptionToStringShorter_dontDropOuterExceptions(result.error()));
        resultPanel.scpResult.set(jErrorView(result.getError()));
      }
      collapsibleResultPanel.expand();
    }

    final public void showStatus(String status) {
      setStatus(status);
    }

    public void setStatus(String status) {
      {
        if (taScript != null)
          taScript.setStatus(" " + unnull(status));
      }
    }

    public void showRuntimeError(Throwable e) {
      showStatus(exceptionToStringShorter(e));
    }

    transient public IF0<VarContext> makeVarContextForExecution;

    public VarContext makeVarContextForExecution() {
      return makeVarContextForExecution != null ? makeVarContextForExecution.get() : makeVarContextForExecution_base();
    }

    final public VarContext makeVarContextForExecution_fallback(IF0<VarContext> _f) {
      return _f != null ? _f.get() : makeVarContextForExecution_base();
    }

    public VarContext makeVarContextForExecution_base() {
      return new VarContext();
    }

    public Object callCompiledObjectWithTimeout(GazelleV_LeftArrowScript.Script script) {
      return callCompiledObjectWithTimeout(scriptTimeout, script);
    }

    public Object callCompiledObjectWithTimeout(double timeoutSeconds, GazelleV_LeftArrowScript.Script script) {
      return callCompiledObjectWithTimeout(timeoutSeconds, script, makeVarContextForExecution());
    }

    public Object callCompiledObjectWithTimeout(GazelleV_LeftArrowScript.Script script, VarContext ctx) {
      return callCompiledObjectWithTimeout(scriptTimeout, script, ctx);
    }

    public Object callCompiledObjectWithTimeout(double timeoutSeconds, GazelleV_LeftArrowScript.Script script, VarContext ctx) {
      return g22utils.evalRegisteredCode(timeoutSeconds, str(script), () -> script.get(ctx));
    }

    public GazelleV_LeftArrowScriptParser makeParser2() {
      var parser = makeParser();
      print("Function containers: " + parser.functionContainers);
      return parser;
    }

    public void showGlobalClassNames() {
      showText("Global Class Names", pnlToString(toCIMap(makeParser().globalClassNames())));
    }

    public void setEditable(boolean b) {
      main.setEditable(textArea(), b);
    }

    transient public IF0<LASCompileResult> newCompileResult;

    public LASCompileResult newCompileResult() {
      return newCompileResult != null ? newCompileResult.get() : newCompileResult_base();
    }

    final public LASCompileResult newCompileResult_fallback(IF0<LASCompileResult> _f) {
      return _f != null ? _f.get() : newCompileResult_base();
    }

    public LASCompileResult newCompileResult_base() {
      return new LASCompileResult();
    }

    public void convertToJava() {
      try {
        ConvertLASToJava converter = new ConvertLASToJava();
        enableScaffolding(converter);
        showText("Java conversion - " + sectionTitle(), strOrNull(converter.get(parsedScript(), true)));
      } catch (Throwable __e) {
        infoBox(__e);
      }
    }
  }

  static public class ClassMaker<A> {

    final public String getClassName() {
      return className();
    }

    public String className() {
      return className;
    }

    public String className;

    public ClassGen cg;

    public JavaClass baked;

    public InMemoryClassLoader classLoader;

    public Class loadedClass;

    final public ClassMaker<A> setPrintDisassembly(boolean printDisassembly) {
      return printDisassembly(printDisassembly);
    }

    public ClassMaker<A> printDisassembly(boolean printDisassembly) {
      this.printDisassembly = printDisassembly;
      return this;
    }

    final public boolean getPrintDisassembly() {
      return printDisassembly();
    }

    public boolean printDisassembly() {
      return printDisassembly;
    }

    public boolean printDisassembly = false;

    public ClassMaker(String className) {
      this.className = className;
      setClassGen(new ClassGen(className, "java.lang.Object", null, Const.ACC_PUBLIC, null));
    }

    public ClassMaker(Class<A> interfaceToImplement) {
      className = randomClassName();
      setClassGen(new ClassGen(className, "java.lang.Object", null, Const.ACC_PUBLIC, new String[] { main.className(interfaceToImplement) }));
      addDefaultConstructor();
    }

    public void addDefaultConstructor() {
      cg.addEmptyConstructor(Const.ACC_PUBLIC);
    }

    public void setClassGen(ClassGen cg) {
      this.cg = cg;
      cg.setMajor(50);
      cg.setMinor(0);
    }

    public JavaClass bake() {
      if (baked == null) {
        baked = cg.getJavaClass();
        if (printDisassembly)
          printClassWithMethods();
      }
      return baked;
    }

    public void printClassWithMethods() {
      print_tabToSingleSpace(bake());
      for (var method : baked.getMethods()) {
        print_tabToSingleSpace("\n" + method);
        print_tabToSingleSpace(method.getCode());
      }
    }

    public byte[] getBytes_cache;

    final public byte[] getBytes() {
      if (getBytes_cache == null)
        getBytes_cache = getBytes_load();
      return getBytes_cache;
    }

    final public byte[] getBytes_load() {
      return toBytes();
    }

    public byte[] toBytes() {
      return bake().getBytes();
    }

    public Class<A> load() {
      if (loadedClass == null) {
        var bytes = toBytes();
        classLoader = new InMemoryClassLoader(myClassLoader());
        loadedClass = (Class) classLoader.defineAClass(className, bytes);
      }
      return loadedClass;
    }

    public A newInstance() {
      return main.newInstance(load());
    }

    public void addField(FieldGen fg) {
      cg.addField(fg.getField());
    }

    public ConstantPoolGen getConstantPool() {
      return cg.getConstantPool();
    }
  }

  public interface IBackgroundProcesses {

    public IBackgroundProcess tempAdd(String name);
  }

  abstract static public class Sleeping implements AutoCloseable, IFieldsToList {

    public Timestamp targetTime;

    public Runnable action;

    public Sleeping() {
    }

    public Sleeping(Timestamp targetTime, Runnable action) {
      this.action = action;
      this.targetTime = targetTime;
    }

    public String toString() {
      return shortClassName_dropNumberPrefix(this) + "(" + targetTime + ", " + action + ")";
    }

    public Object[] _fieldsToList() {
      return new Object[] { targetTime, action };
    }

    public long remainingMS() {
      return targetTime.minus(tsNow());
    }
  }

  static public class G22Label extends ConceptWithGlobalID {

    public String name;

    public String toString() {
      return name;
    }

    final public boolean textIs(String text) {
      return nameIs(text);
    }

    public boolean nameIs(String text) {
      return eqic(name, text);
    }
  }

  static public class TokenRange extends IntRange {

    public TokenRange() {
    }

    public TokenRange(int start, int end) {
      this.end = end;
      this.start = start;
    }
  }

  static public interface G22MasterStuff {

    public Object openDatabase(File dir);

    public void closeDatabase(File dir);

    public void switchToDatabase(File dir);

    public Collection<File> openConceptDirs();

    public G22MasterStuff onLoadedDBsChange(Runnable r);

    public G22MasterStuff removeLoadedDBsChangeListener(Runnable r);

    public IF1<String, Class> makeClassFinder();

    public IF0WithChangeListeners<Integer> lvGazelleUserCount();

    public LASClassLoader lasClassLoader();
  }

  static public class FileWatchService implements AutoCloseable {

    final public FileWatchService setInterval(int interval) {
      return interval(interval);
    }

    public FileWatchService interval(int interval) {
      this.interval = interval;
      return this;
    }

    final public int getInterval() {
      return interval();
    }

    public int interval() {
      return interval;
    }

    public int interval = 50;

    public int sleepSeconds = 60;

    public WatchService watchService;

    public MultiMap<WatchKey, IVF1<File>> listeners = new MultiMap();

    public Thread pollThread;

    volatile public boolean closed = false;

    public FileWatchService() {
      try {
        watchService = FileSystems.getDefault().newWatchService();
      } catch (Exception __e) {
        throw rethrow(__e);
      }
    }

    public void close() {
      closed = true;
      {
        cleanUp(watchService);
        watchService = null;
      }
    }

    public WatchKey addListenerImpl(File path, IVF1<File> listener, WatchEvent.Kind... eventKinds) {
      try {
        if (path == null)
          return null;
        startPollThread();
        WatchKey key = path.toPath().register(watchService, eventKinds);
        listeners.put(key, listener);
        return key;
      } catch (Exception __e) {
        throw rethrow(__e);
      }
    }

    public void addNonRecursiveListener(File path, IVF1<File> listener) {
      addListenerImpl(path, listener, jdk_watchService_allEventKinds());
    }

    public void addRecursiveListener(File path, IVF1<File> listener) {
      Set<File> listeningTo = synchroSet();
      IVF1<File> listener2 = new IVF1<File>() {

        public void get(File f) {
          boolean isDir = f.isDirectory();
          if (isDir && listeningTo.add(f))
            try {
              addListenerImpl(f, this, jdk_watchService_allEventKinds());
            } catch (Throwable __e) {
              print(exceptionToStringShort(__e));
            }
          callF(listener, f);
        }
      };
      addListenerImpl(path, listener2, jdk_watchService_allEventKinds());
      for (File subDir : findAllDirs(path)) addListenerImpl(subDir, listener2, jdk_watchService_allEventKinds());
    }

    synchronized public void startPollThread() {
      if (pollThread != null)
        return;
      pollThread = startThread("File Watch Service", new Runnable() {

        public void run() {
          try {
            try {
              while (licensed() && !closed) {
                WatchKey key = watchService.poll(sleepSeconds, TimeUnit.SECONDS);
                if (key != null) {
                  Path dir = (Path) (key.watchable());
                  sleep(interval);
                  List<WatchEvent<?>> events = key.pollEvents();
                  LinkedHashSet<File> changedFiles = new LinkedHashSet();
                  for (WatchEvent<?> event : reversedIterator(events)) {
                    try {
                      final Path changed = (Path) event.context();
                      if (changed == null)
                        continue;
                      File full = newFile(dir.toFile(), changed.toFile().getPath());
                      changedFiles.add(full);
                    } catch (Throwable __e) {
                      printStackTrace(__e);
                    }
                  }
                  for (File f : changedFiles) pcallFAll(listeners.get(key), f);
                  key.reset();
                }
              }
            } catch (ClosedWatchServiceException e) {
            }
          } catch (Exception __e) {
            throw rethrow(__e);
          }
        }

        public String toString() {
          return "try {\r\n        while (licensed() && !closed) { \r\n          WatchKey key = wat...";
        }
      });
    }
  }

  static public class OKOrError<A> implements IF0<A> {

    public A value;

    final public Throwable getError() {
      return error();
    }

    public Throwable error() {
      return error;
    }

    public Throwable error;

    public OKOrError() {
    }

    public OKOrError(A value) {
      this.value = value;
    }

    public OKOrError(boolean dummy, Throwable error) {
      this.error = error;
      assertNotNull(error);
    }

    final public boolean isOK() {
      return ok();
    }

    public boolean ok() {
      return error == null;
    }

    public boolean isError() {
      return error != null;
    }

    public String toString() {
      return ok() ? str(value) : "Error: " + str(error);
    }

    public A get() {
      return !ok() ? null : value;
    }

    public A getMandatory() {
      if (!ok())
        throw rethrow(error);
      return value;
    }

    static public <A> OKOrError<A> ok(A a) {
      return new OKOrError(a);
    }

    static public OKOrError error(Throwable error) {
      return new OKOrError(false, error);
    }

    public void setValue(A value) {
      this.value = value;
      error = null;
    }

    public void setError(Throwable error) {
      this.value = null;
      this.error = error;
    }

    public void copyFrom(OKOrError<A> x) {
      value = x.value;
      error = x.error;
    }
  }

  static public class ConceptWithGlobalID extends Concept implements IHasGlobalID {

    public GlobalID globalID = aGlobalIDObjUnlessLoading();

    public GlobalID globalID() {
      return globalID;
    }

    public String globalIDStr() {
      return strOrNull(globalID);
    }

    public String prependGlobalID(String s) {
      return globalID == null ? s : "[" + globalID + "] " + s;
    }
  }

  static public class LASCompileResult {

    final public LASCompileResult setScript(String script) {
      return script(script);
    }

    public LASCompileResult script(String script) {
      this.script = script;
      return this;
    }

    final public String getScript() {
      return script();
    }

    public String script() {
      return script;
    }

    public String script;

    final public LASCompileResult setParser(GazelleV_LeftArrowScriptParser parser) {
      return parser(parser);
    }

    public LASCompileResult parser(GazelleV_LeftArrowScriptParser parser) {
      this.parser = parser;
      return this;
    }

    final public GazelleV_LeftArrowScriptParser getParser() {
      return parser();
    }

    public GazelleV_LeftArrowScriptParser parser() {
      return parser;
    }

    public GazelleV_LeftArrowScriptParser parser;

    final public LASCompileResult setCompileError(Throwable compileError) {
      return compileError(compileError);
    }

    public LASCompileResult compileError(Throwable compileError) {
      this.compileError = compileError;
      return this;
    }

    final public Throwable getCompileError() {
      return compileError();
    }

    public Throwable compileError() {
      return compileError;
    }

    public Throwable compileError;

    public GazelleV_LeftArrowScript.Script parsedScript;

    public RunResultWithTimestamps compileLog;

    public String toString() {
      if (compileError != null)
        return errorToString();
      if (parsedScript == null)
        return "Not compiled yet";
      return "Compiled OK" + (compileLog == null ? "" : " in " + n2(max(1, compileLog.duration().toMillis())) + " ms");
    }

    public String errorToString() {
      return exceptionToStringShorter_dontDropOuterExceptions(compileError);
    }

    public boolean runnable() {
      return parsedScript != null;
    }

    public void compile() {
      compileLog = runResultWithTimestamps(() -> {
        if (parser == null)
          parser = makeParser();
        return parsedScript = parser.parse(script);
      });
      if (compileLog.isError()) {
        var e = compileLog.getError();
        print(e);
        compileError(e);
      }
    }

    public GazelleV_LeftArrowScript.Script parsedScript() {
      return parsedScript;
    }

    public GazelleV_LeftArrowScript.Script parsedScriptMandatory() {
      if (compileError != null)
        throw fail(compileError);
      return parsedScript;
    }

    transient public IF0<GazelleV_LeftArrowScriptParser> makeParser;

    public GazelleV_LeftArrowScriptParser makeParser() {
      return makeParser != null ? makeParser.get() : makeParser_base();
    }

    final public GazelleV_LeftArrowScriptParser makeParser_fallback(IF0<GazelleV_LeftArrowScriptParser> _f) {
      return _f != null ? _f.get() : makeParser_base();
    }

    public GazelleV_LeftArrowScriptParser makeParser_base() {
      return null;
    }

    public LineAndColumn errorLineAndCol() {
      return parseLineAndColumn(str(compileError));
    }
  }

  static public class WithTimestamp<A> extends Var<A> {

    public long timestamp;

    final public Timestamp timestamp() {
      return getTimestamp();
    }

    final public Timestamp timeStamp() {
      return getTimestamp();
    }

    public Timestamp getTimestamp() {
      return timestamp == 0 ? null : new Timestamp(timestamp);
    }

    public WithTimestamp() {
    }

    public WithTimestamp(long timestamp, A value) {
      super(value);
      this.timestamp = timestamp;
    }

    public WithTimestamp(A value) {
      this(now(), value);
    }

    public Timestamp timestampObj() {
      return timestamp == 0 ? null : new Timestamp(timestamp);
    }

    public String toString() {
      return toStringWithTimestamp(super.toString());
    }

    public String toStringQuoted() {
      return toStringWithTimestamp(quote(super.toString()));
    }

    public String toStringWithTimestamp(String s) {
      return s + " at " + localDateWithSeconds(timestamp);
    }

    public boolean olderThanMinutes(double minutes) {
      return elapsedMinutes_timestamp(timestamp) >= minutes;
    }

    public boolean olderThanSeconds(double seconds) {
      return elapsedSeconds_timestamp(timestamp) >= seconds;
    }
  }

  static public class Var<A> implements IVar<A>, ISetter<A> {

    public Var() {
    }

    public Var(A v) {
      this.v = v;
    }

    public A v;

    public synchronized void set(A a) {
      if (v != a) {
        v = a;
        notifyAll();
      }
    }

    public synchronized A get() {
      return v;
    }

    public synchronized boolean has() {
      return v != null;
    }

    public void clear() {
      set(null);
    }

    public String toString() {
      return str(this.get());
    }
  }

  static public class CollapsibleLeftPanel extends MetaWithChangeListeners implements Swingable {

    public transient FieldVar<String> varSidePanelName_cache;

    public FieldVar<String> varSidePanelName() {
      if (varSidePanelName_cache == null)
        varSidePanelName_cache = varSidePanelName_load();
      return varSidePanelName_cache;
    }

    public FieldVar<String> varSidePanelName_load() {
      return new FieldVar<String>(this, "sidePanelName", () -> sidePanelName(), sidePanelName -> sidePanelName(sidePanelName));
    }

    final public CollapsibleLeftPanel setSidePanelName(String sidePanelName) {
      return sidePanelName(sidePanelName);
    }

    public CollapsibleLeftPanel sidePanelName(String sidePanelName) {
      if (!eq(this.sidePanelName, sidePanelName)) {
        this.sidePanelName = sidePanelName;
        change();
      }
      return this;
    }

    final public String getSidePanelName() {
      return sidePanelName();
    }

    public String sidePanelName() {
      return sidePanelName;
    }

    volatile public String sidePanelName;

    public JComponent sideComponent, mainComponent;

    public JSplitPane splitPane;

    public transient FieldVar<Boolean> varExpanded_cache;

    public FieldVar<Boolean> varExpanded() {
      if (varExpanded_cache == null)
        varExpanded_cache = varExpanded_load();
      return varExpanded_cache;
    }

    public FieldVar<Boolean> varExpanded_load() {
      return new FieldVar<Boolean>(this, "expanded", () -> expanded(), expanded -> expanded(expanded));
    }

    final public CollapsibleLeftPanel setExpanded(boolean expanded) {
      return expanded(expanded);
    }

    public CollapsibleLeftPanel expanded(boolean expanded) {
      if (!eq(this.expanded, expanded)) {
        this.expanded = expanded;
        change();
      }
      return this;
    }

    final public boolean getExpanded() {
      return expanded();
    }

    public boolean expanded() {
      return expanded;
    }

    volatile public boolean expanded = false;

    public SingleComponentPanel scp = singleComponentPanel();

    public CollapsibleLeftPanel(boolean expanded, String sidePanelName, JComponent sideComponent, JComponent mainComponent) {
      this.mainComponent = mainComponent;
      this.sideComponent = sideComponent;
      this.sidePanelName = sidePanelName;
      this.expanded = expanded;
    }

    public void expand() {
      if (scaffolding())
        print("CollapsibleLeftPanel.expand");
      setExpanded(true);
    }

    public void collapse() {
      setExpanded(false);
    }

    public void updateScp() {
      swing(() -> {
        if (metaGet("scaffolding") != null)
          scaffoldCalled(this, "updateScp");
        if (expanded) {
          splitPane().setRightComponent(mainComponent);
          scp.set(splitPane());
        } else {
          splitPane().setRightComponent(jpanel());
          scp.set(westAndCenterWithMargin(sidePanelMargins(vstack(expandButton())), mainComponent));
        }
      });
    }

    public JComponent expandButton() {
      return jClickableImage_instantToolTip("#1103075", "Expand " + sidePanelName, new Runnable() {

        public void run() {
          try {
            expand();
          } catch (Exception __e) {
            throw rethrow(__e);
          }
        }

        public String toString() {
          return "expand();";
        }
      });
    }

    public JComponent collapseButton() {
      return jClickableImage_instantToolTip("#1103076", "Collapse " + sidePanelName, new Runnable() {

        public void run() {
          try {
            collapse();
          } catch (Exception __e) {
            throw rethrow(__e);
          }
        }

        public String toString() {
          return "collapse();";
        }
      });
    }

    public JComponent wrappedSideComponent() {
      return sidePanelMargins(northAndCenterWithMargin(westAndCenterWithMargin(collapseButton(), liveValueLabel(varSidePanelName())), sideComponent));
    }

    public JSplitPane splitPane() {
      if (scaffolding())
        print("splitPane " + splitPane);
      if (splitPane == null) {
        splitPane = jhsplit(0.25, wrappedSideComponent(), null);
        varExpanded().onChangeAndNow(new Runnable() {

          public void run() {
            try {
              updateScp();
            } catch (Exception __e) {
              throw rethrow(__e);
            }
          }

          public String toString() {
            return "updateScp();";
          }
        });
      }
      return splitPane;
    }

    transient public IF1<JComponent, JComponent> sidePanelMargins;

    public JComponent sidePanelMargins(JComponent c) {
      return sidePanelMargins != null ? sidePanelMargins.get(c) : sidePanelMargins_base(c);
    }

    final public JComponent sidePanelMargins_fallback(IF1<JComponent, JComponent> _f, JComponent c) {
      return _f != null ? _f.get(c) : sidePanelMargins_base(c);
    }

    public JComponent sidePanelMargins_base(JComponent c) {
      return c;
    }

    public JComponent visualize() {
      splitPane();
      return scp;
    }
  }

  public interface IF0WithChangeListeners<A> extends IF0<A>, IHasChangeListeners {
  }

  static public class ConvertLASToJava extends Meta {

    public Object convert(LASClassDef.FieldDef field) {
      return "/*settable?*/ " + shortClassName(field.type()) + " " + field.name() + ";";
    }

    public Object convert(GazelleV_LeftArrowScript.FunctionDef f) {
      return "O " + f.name + "(" + joinWithComma(map(f.args, arg -> "O " + arg)) + ") {\n" + indentx(convert(f.body, true)) + "}\n";
    }

    public Object convertWithLeadingSpace(GazelleV_LeftArrowScript.Evaluable o) {
      return leadingSpace(o, "") + convert(o);
    }

    public Object convertWithLeadingSpace2(GazelleV_LeftArrowScript.Evaluable o) {
      return replaceIfEqual(leadingSpace(o, ""), " ", "") + convert(o);
    }

    public String leadingSpace(GazelleV_LeftArrowScript.Evaluable o, String defaultSpace) {
      String space = null;
      var src = o.tokenRangeWithSrc();
      if (src != null)
        space = src.startPtr().mapIdx(idx -> idx & ~1).get();
      return or2(space, defaultSpace);
    }

    public String trailingSpace(GazelleV_LeftArrowScript.Evaluable o, String defaultSpace) {
      String space = null;
      var src = o.tokenRangeWithSrc();
      if (src != null) {
        String rawSpace = src.endPtr().mapIdx(idx -> idx & ~1).get();
        space = replaceRegexp(rawSpace, "\n[ \t]+$", "\n");
        if (scaffoldingEnabled())
          printVars("trailingSpace", "rawSpace", quote(rawSpace), "space", quote(space));
      }
      return or2(space, defaultSpace);
    }

    public Object getInstruction(GazelleV_LeftArrowScript.Evaluable o) {
      Object inner = convert(o);
      boolean needSemicolon = !(o instanceof GazelleV_LeftArrowScript.ClassDef) && !(o instanceof GazelleV_LeftArrowScript.ForEachBase);
      String space = trailingSpace(o, "\n");
      if (scaffoldingEnabled())
        printVars("space", space, "o", className(o), "srcText", quote(o.srcText()), "inner", inner);
      return inner + (needSemicolon ? ";" : "") + space;
    }

    public Object convert(GazelleV_LeftArrowScript.Script script, boolean returnLastResult) {
      var steps = asList(script.steps);
      if (returnLastResult) {
        if (empty(steps))
          return "return null;";
        var last = last(steps);
        if (!(last instanceof GazelleV_LeftArrowScript.ReturnFromScript) && !(last instanceof GazelleV_LeftArrowScript.ClassDef))
          setLast(steps, new GazelleV_LeftArrowScript.ReturnFromScript(script, last));
      }
      return concatMapStrings(i -> str(getInstruction(i)), steps);
    }

    public Object convert(GazelleV_LeftArrowScript.Evaluable o, boolean returnLastResult) {
      if (o instanceof GazelleV_LeftArrowScript.Script)
        return convert(((GazelleV_LeftArrowScript.Script) o), returnLastResult);
      return convert(o);
    }

    public Object convert(GazelleV_LeftArrowScript.Evaluable o) {
      if (o == null)
        return null;
      if (o instanceof GazelleV_LeftArrowScript.GetVar)
        return ((GazelleV_LeftArrowScript.GetVar) o).var;
      if (o instanceof GazelleV_LeftArrowScript.Script)
        return convert(((GazelleV_LeftArrowScript.Script) o), false);
      if (o instanceof GazelleV_LeftArrowScript.ClassDef) {
        LASClassDef c = ((GazelleV_LeftArrowScript.ClassDef) o).lasClass.classDef;
        return "class " + c.userGivenName + " " + curly("\n" + appendNewLineIfNempty(indentx(joinNemptiesWithEmptyLines(lines_rtrim(map(__70 -> convert(__70), c.fields)), lines_rtrim(map(__71 -> convert(__71), c.methods))))));
      }
      if (o instanceof GazelleV_LeftArrowScript.Assignment)
        return ((GazelleV_LeftArrowScript.Assignment) o).var + " = " + convert(((GazelleV_LeftArrowScript.Assignment) o).expression);
      if (o instanceof GazelleV_LeftArrowScript.VarDeclaration)
        return "var " + ((GazelleV_LeftArrowScript.VarDeclaration) o).var + " = " + convert(((GazelleV_LeftArrowScript.VarDeclaration) o).expression);
      if (o instanceof GazelleV_LeftArrowScript.CallMethod) {
        String targetStr = null;
        var targetType = ((GazelleV_LeftArrowScript.CallMethod) o).target.returnType();
        if (targetType.knownValue()) {
          Object target = targetType.value();
          if (target instanceof Class && eqOneOf(shortClassName((Class) target), "main", "utils"))
            targetStr = "";
        }
        if (targetStr == null)
          targetStr = str(convert(((GazelleV_LeftArrowScript.CallMethod) o).target));
        return (empty(targetStr) ? "" : targetStr + ".") + new FunctionCall(((GazelleV_LeftArrowScript.CallMethod) o).methodName, map(__72 -> convertWithLeadingSpace2(__72), ((GazelleV_LeftArrowScript.CallMethod) o).args));
      }
      if (o instanceof GazelleV_LeftArrowScript.SetField)
        return convert(((GazelleV_LeftArrowScript.SetField) o).target) + "." + ((GazelleV_LeftArrowScript.SetField) o).name + " = " + convert(((GazelleV_LeftArrowScript.SetField) o).expr);
      if (o instanceof GazelleV_LeftArrowScript.CallMethodOrGetField)
        return convert(((GazelleV_LeftArrowScript.CallMethodOrGetField) o).target) + "." + ((GazelleV_LeftArrowScript.CallMethodOrGetField) o).name + "()";
      if (o instanceof GazelleV_LeftArrowScript.NewObject)
        return "new " + new FunctionCall(shortClassName(((GazelleV_LeftArrowScript.NewObject) o).c), map(__73 -> convert(__73), ((GazelleV_LeftArrowScript.NewObject) o).args)).toStringWithOptionalParens();
      if (o instanceof GazelleV_LeftArrowScript.IfThen)
        return "if (" + convert(((GazelleV_LeftArrowScript.IfThen) o).condition) + ") " + curlyIfScript(((GazelleV_LeftArrowScript.IfThen) o).body) + (((GazelleV_LeftArrowScript.IfThen) o).elseBranch == null ? "" : " else " + curlyIfScript(((GazelleV_LeftArrowScript.IfThen) o).elseBranch));
      if (o instanceof GazelleV_LeftArrowScript.Const) {
        var c = (GazelleV_LeftArrowScript.Const) o;
        {
          var __1 = c == null ? null : c.srcText();
          if (__1 != null)
            return __1;
        }
        try {
          return toJava(((GazelleV_LeftArrowScript.Const) o).value);
        } catch (Throwable __e) {
          printStackTrace(__e);
        }
      }
      if (o instanceof GazelleV_LeftArrowScript.ForEach)
        return "fOr (" + ((GazelleV_LeftArrowScript.ForEach) o).var + " : " + convert(((GazelleV_LeftArrowScript.ForEach) o).collection) + ") {\n" + indentx(convert(((GazelleV_LeftArrowScript.ForEach) o).body, false)) + "\n}";
      if (o instanceof GazelleV_LeftArrowScript.CurriedScriptFunctionLambda) {
        int nArgs = ((GazelleV_LeftArrowScript.CurriedScriptFunctionLambda) o).implementedMethod.getParameterCount();
        List<String> args = countIteratorToList_incl(1, nArgs, i -> "_" + i);
        List fullArgs = concatLists(allToString(map(__74 -> convert(__74), ((GazelleV_LeftArrowScript.CurriedScriptFunctionLambda) o).curriedArgs)), args);
        return roundBracketed(shortClassName(((GazelleV_LeftArrowScript.CurriedScriptFunctionLambda) o).intrface)) + " " + lambdaArgsToString_pureJava(args) + " -> " + new FunctionCall(((GazelleV_LeftArrowScript.CurriedScriptFunctionLambda) o).f.name, fullArgs);
      }
      if (o instanceof GazelleV_LeftArrowScript.LambdaDef)
        return roundBracketed(shortClassName(((GazelleV_LeftArrowScript.LambdaDef) o).intrface)) + " " + joinNemptiesWithSpace(lambdaArgsToString_pureJava(((GazelleV_LeftArrowScript.LambdaDef) o).args), "-> " + curlyIfScript(((GazelleV_LeftArrowScript.LambdaDef) o).body));
      if (o instanceof GazelleV_LeftArrowScript.ReturnFromScript)
        return "ret " + convert(((GazelleV_LeftArrowScript.ReturnFromScript) o).value);
      warn("Can't convert to Java: " + className(o));
      if (o instanceof GazelleV_LeftArrowScript.Base) {
        var b = (GazelleV_LeftArrowScript.Base) o;
        {
          var __2 = b == null ? null : b.srcText();
          if (__2 != null)
            return __2;
        }
      }
      warn("No source reference in script object: " + className(o));
      return str(o);
    }

    public Object curlyIfScript(GazelleV_LeftArrowScript.Evaluable o) {
      if (o instanceof GazelleV_LeftArrowScript.Script)
        return "{\n" + indentx(convert((GazelleV_LeftArrowScript.Script) o)) + "\n}";
      return convert(o);
    }

    public String get(GazelleV_LeftArrowScript.Evaluable o, boolean returnLastResult) {
      String src = strOrEmpty(convert(o, returnLastResult));
      JavaXPeepholeShortener shortener = new JavaXPeepholeShortener(javaTok(src));
      shortener.run();
      return join(shortener.tok);
    }
  }

  static public class G22GalleryImage extends Concept {

    public File path;

    public String toString() {
      return fileName(path);
    }

    public boolean imageExists() {
      return fileExists(path);
    }

    public BufferedImage load() {
      return loadImage2(path);
    }
  }

  static public class JPopDownButton extends JButton {

    public String menuPosition = "left";

    public JPopDownButton() {
      this("");
    }

    public JPopDownButton(String text) {
      super(joinNemptiesWithSpace(text, unicode_downPointingTriangle()));
      main.addActionListener(this, new Runnable() {

        public void run() {
          try {
            openMenu();
          } catch (Exception __e) {
            throw rethrow(__e);
          }
        }

        public String toString() {
          return "openMenu();";
        }
      });
    }

    public JPopDownButton(IVF1<JPopupMenu> fillMenu) {
      this();
      this.fillMenu = fillMenu;
    }

    transient public Set<IVF1<JPopupMenu>> onFillingMenu;

    public JPopDownButton onFillingMenu(IVF1<JPopupMenu> f) {
      onFillingMenu = createOrAddToSyncLinkedHashSet(onFillingMenu, f);
      return this;
    }

    public JPopDownButton removeFillingMenuListener(IVF1<JPopupMenu> f) {
      main.remove(onFillingMenu, f);
      return this;
    }

    public void fillingMenu(JPopupMenu menu) {
      if (onFillingMenu != null)
        for (var listener : onFillingMenu) pcallF_typed(listener, menu);
    }

    transient public IVF1<JPopupMenu> fillMenu;

    public void fillMenu(JPopupMenu menu) {
      if (fillMenu != null)
        fillMenu.get(menu);
      else
        fillMenu_base(menu);
    }

    final public void fillMenu_fallback(IVF1<JPopupMenu> _f, JPopupMenu menu) {
      if (_f != null)
        _f.get(menu);
      else
        fillMenu_base(menu);
    }

    public void fillMenu_base(JPopupMenu menu) {
      fillingMenu(menu);
    }

    public void openMenu() {
      JPopupMenu menu = new JPopupMenu();
      int emptyCount = menu.getComponentCount();
      fillMenu(menu);
      if (menu.getComponentCount() == emptyCount)
        return;
      int x = 0;
      if (eq(menuPosition, "center"))
        x = (getWidth() - getPreferredWidth(menu)) / 2;
      else if (eq(menuPosition, "right"))
        x = getWidth() - getPreferredWidth(menu);
      menu.show(this, x, getHeight());
    }
  }

  public interface IStringifier<A> {

    public String toString(A o);
  }

  static public class RSyntaxTextAreaWithSearch implements SearchListener, Swingable {

    public JPanel panel;

    final public RSyntaxTextArea getTextArea() {
      return textArea();
    }

    public RSyntaxTextArea textArea() {
      return textArea;
    }

    public RSyntaxTextArea textArea;

    public CollapsibleSectionPanel csp;

    public FindDialog findDialog;

    public ReplaceDialog replaceDialog;

    public FindToolBar findToolBar;

    public ReplaceToolBar replaceToolBar;

    public StatusBar statusBar;

    public RSyntaxTextAreaWithSearch() {
      init();
    }

    public RSyntaxTextAreaWithSearch(IF1<JComponent, JComponent> wrapStatusLabel) {
      this.wrapStatusLabel = wrapStatusLabel;
      init();
    }

    public RSyntaxTextAreaWithSearch(String text) {
      init();
      setText(text);
    }

    public RSyntaxTextAreaWithSearch(RSyntaxTextArea textArea) {
      this.textArea = textArea;
      init();
    }

    public JComponent visualize() {
      return panel;
    }

    public void init() {
      swing(() -> {
        rsyntaxTextArea_fixNumPad();
        initSearchDialogs();
        panel = new JPanel(new BorderLayout());
        csp = new CollapsibleSectionPanel();
        panel.add(csp);
        if (textArea == null)
          textArea = javaxSyntaxTextArea();
        RTextScrollPane sp = new RTextScrollPane(textArea);
        csp.add(sp);
        ErrorStrip errorStrip = new ErrorStrip(textArea);
        panel.add(errorStrip, BorderLayout.LINE_END);
        statusBar = new StatusBar();
        panel.add(statusBar, BorderLayout.SOUTH);
      });
    }

    transient public IF1<JComponent, JComponent> wrapStatusLabel;

    public JComponent wrapStatusLabel(JComponent label) {
      return wrapStatusLabel != null ? wrapStatusLabel.get(label) : wrapStatusLabel_base(label);
    }

    final public JComponent wrapStatusLabel_fallback(IF1<JComponent, JComponent> _f, JComponent label) {
      return _f != null ? _f.get(label) : wrapStatusLabel_base(label);
    }

    public JComponent wrapStatusLabel_base(JComponent label) {
      return label;
    }

    public void addItem(Action a, ButtonGroup bg, JMenu menu) {
      JRadioButtonMenuItem item = new JRadioButtonMenuItem(a);
      bg.add(item);
      menu.add(item);
    }

    public void menuLessOperation() {
      swing(() -> {
        var mb = createMenuBar();
        for (var menu : getMenus(mb)) for (var menuItem : getMenuItems(menu)) {
          var ks = menuItem.getAccelerator();
          if (ks != null) {
            var action = menuItem.getAction();
            textArea.getInputMap().put(ks, action);
          }
        }
      });
    }

    public JMenuBar createMenuBar() {
      JMenuBar mb = new JMenuBar();
      JMenu menu = new JMenu("Search");
      menu.add(new JMenuItem(new ShowFindDialogAction()));
      menu.add(new JMenuItem(new ShowReplaceDialogAction()));
      menu.add(new JMenuItem(new GoToLineAction()));
      menu.addSeparator();
      int ctrl = getToolkit().getMenuShortcutKeyMask();
      int shift = InputEvent.SHIFT_MASK;
      KeyStroke ks = KeyStroke.getKeyStroke(KeyEvent.VK_F, ctrl | shift);
      Action a = csp.addBottomComponent(ks, findToolBar);
      a.putValue(Action.NAME, "Show Find Search Bar");
      menu.add(new JMenuItem(a));
      ks = KeyStroke.getKeyStroke(KeyEvent.VK_H, ctrl | shift);
      a = csp.addBottomComponent(ks, replaceToolBar);
      a.putValue(Action.NAME, "Show Replace Search Bar");
      menu.add(new JMenuItem(a));
      mb.add(menu);
      return mb;
    }

    public String getSelectedText() {
      return textArea.getSelectedText();
    }

    public void initSearchDialogs() {
      findDialog = new FindDialog((java.awt.Dialog) null, this);
      replaceDialog = new ReplaceDialog((java.awt.Dialog) null, this);
      SearchContext context = findDialog.getSearchContext();
      replaceDialog.setSearchContext(context);
      findToolBar = new FindToolBar(this);
      findToolBar.setSearchContext(context);
      replaceToolBar = new ReplaceToolBar(this);
      replaceToolBar.setSearchContext(context);
    }

    @Override
    public void searchEvent(SearchEvent e) {
      SearchEvent.Type type = e.getType();
      SearchContext context = e.getSearchContext();
      SearchResult result = null;
      switch(type) {
        default:
        case MARK_ALL:
          result = SearchEngine.markAll(textArea, context);
          break;
        case FIND:
          result = SearchEngine.find(textArea, context);
          if (!result.wasFound()) {
            Caret c = textArea.getCaret();
            int pos = c.getDot();
            if (context.getSearchForward()) {
              c.setDot(0);
            } else {
              c.setDot(textArea.getDocument().getLength());
            }
            result = SearchEngine.find(textArea, context);
            if (!result.wasFound()) {
              c.setDot(pos);
              UIManager.getLookAndFeel().provideErrorFeedback(textArea);
            }
          }
          break;
        case REPLACE:
          result = SearchEngine.replace(textArea, context);
          if (!result.wasFound()) {
            UIManager.getLookAndFeel().provideErrorFeedback(textArea);
          }
          break;
        case REPLACE_ALL:
          result = SearchEngine.replaceAll(textArea, context);
          JOptionPane.showMessageDialog(null, result.getCount() + " occurrences replaced.");
          break;
      }
      String text = null;
      if (result.wasFound()) {
        text = "Text found; occurrences marked: " + result.getMarkedCount();
      } else if (type == SearchEvent.Type.MARK_ALL) {
        if (result.getMarkedCount() > 0) {
          text = "Occurrences marked: " + result.getMarkedCount();
        } else {
          text = "";
        }
      } else {
        text = "Text not found";
      }
      setStatus(text);
    }

    public class GoToLineAction extends AbstractAction {

      public GoToLineAction() {
        super("Go To Line...");
        int c = getToolkit().getMenuShortcutKeyMask();
        putValue(ACCELERATOR_KEY, KeyStroke.getKeyStroke(KeyEvent.VK_L, c));
      }

      public void actionPerformed(ActionEvent e) {
        findDialog.setVisible(false);
        replaceDialog.setVisible(false);
        GoToDialog dialog = new GoToDialog((java.awt.Dialog) null);
        dialog.setMaxLineNumberAllowed(textArea.getLineCount());
        showDialogOnSameScreen(dialog, panel);
        int line = dialog.getLineNumber();
        if (line > 0) {
          try {
            textArea.setCaretPosition(textArea.getLineStartOffset(line - 1));
          } catch (BadLocationException ble) {
            UIManager.getLookAndFeel().provideErrorFeedback(textArea);
            ble.printStackTrace();
          }
        }
      }
    }

    public class ShowFindDialogAction extends AbstractAction {

      public ShowFindDialogAction() {
        super("Find...");
        int c = getToolkit().getMenuShortcutKeyMask();
        putValue(ACCELERATOR_KEY, KeyStroke.getKeyStroke(KeyEvent.VK_F, c));
      }

      public void actionPerformed(ActionEvent e) {
        replaceDialog.setVisible(false);
        showDialogOnSameScreen(findDialog, panel);
      }
    }

    public class ShowReplaceDialogAction extends AbstractAction {

      public ShowReplaceDialogAction() {
        super("Replace...");
        int c = getToolkit().getMenuShortcutKeyMask();
        putValue(ACCELERATOR_KEY, KeyStroke.getKeyStroke(KeyEvent.VK_H, c));
      }

      public void actionPerformed(ActionEvent e) {
        findDialog.setVisible(false);
        showDialogOnSameScreen(replaceDialog, panel);
      }
    }

    public class StatusBar extends JPanel {

      public JLabel label;

      public StatusBar() {
        label = new JLabel(" ");
        setLayout(new BorderLayout());
        add(wrapStatusLabel(label), BorderLayout.CENTER);
        add(new JLabel(new SizeGripIcon()), BorderLayout.EAST);
      }

      public void setText(String label) {
        main.setText(this.label, label);
      }
    }

    public void setStatus(String text) {
      statusBar.setText(text);
    }

    public void setText(String text) {
      main.setText(textArea, text);
    }

    public String getText() {
      return main.getText(textArea);
    }

    public void setEditorFont(final Font font) {
      swing(() -> {
        SyntaxScheme ss = textArea.getSyntaxScheme();
        ss = (SyntaxScheme) ss.clone();
        for (int i = 0; i < ss.getStyleCount(); i++) if (ss.getStyle(i) != null)
          ss.getStyle(i).font = font;
        textArea.setSyntaxScheme(ss);
        textArea.setFont(font);
      });
    }

    public Font getEditorFont() {
      return swing(new F0<Font>() {

        public Font get() {
          try {
            return textArea.getFont();
          } catch (Exception __e) {
            throw rethrow(__e);
          }
        }

        public String toString() {
          return "return textArea.getFont();";
        }
      });
    }

    public int getEditorFontSize() {
      return getEditorFont().getSize();
    }

    public void setEditorFontSize(int size) {
      setEditorFont(deriveFont(getEditorFont(), size));
    }

    public RSyntaxDocument getDocument() {
      return (RSyntaxDocument) textArea.getDocument();
    }

    public Toolkit getToolkit() {
      return panel.getToolkit();
    }

    public JLabel statusLabel() {
      return statusBar.label;
    }
  }

  static public class SimpleLiveValue<A> extends LiveValue<A> implements IVarWithNotify<A> {

    transient public Set<Runnable> onChange;

    public SimpleLiveValue<A> onChange(Runnable r) {
      onChange = createOrAddToSyncLinkedHashSet(onChange, r);
      return this;
    }

    public SimpleLiveValue<A> removeChangeListener(Runnable r) {
      main.remove(onChange, r);
      return this;
    }

    public void change() {
      if (onChange != null)
        for (var listener : onChange) pcallF_typed(listener);
    }

    public Class<A> type;

    volatile public A value;

    public SimpleLiveValue(Class<A> type) {
      this.type = type;
    }

    public SimpleLiveValue(Class<A> type, A value) {
      this.value = value;
      this.type = type;
    }

    public Class<A> getType() {
      return type;
    }

    public A get() {
      return value;
    }

    public void fireChanged() {
      change();
    }

    public void set(A a) {
      if (neq(value, a)) {
        value = a;
        fireChanged();
      }
    }
  }

  static public class ConceptWithChangeListeners extends Concept implements IHasChangeListeners, ChangeTriggerable {

    transient public Set<Runnable> onChange;

    public ConceptWithChangeListeners onChange(Runnable r) {
      onChange = createOrAddToSyncLinkedHashSet(onChange, r);
      return this;
    }

    public ConceptWithChangeListeners removeChangeListener(Runnable r) {
      main.remove(onChange, r);
      return this;
    }

    public void fireChange() {
      if (onChange != null)
        for (var listener : onChange) pcallF_typed(listener);
    }

    public void _onChange() {
      super._onChange();
      fireChange();
    }

    public void change() {
      super.change();
    }
  }

  static public class G22AnalysisContext implements IFieldsToList {

    public G22Utils g22utils;

    public BufferedImage image;

    public G22AnalysisContext() {
    }

    public G22AnalysisContext(G22Utils g22utils, BufferedImage image) {
      this.image = image;
      this.g22utils = g22utils;
    }

    public String toString() {
      return shortClassName_dropNumberPrefix(this) + "(" + g22utils + ", " + image + ")";
    }

    public Object[] _fieldsToList() {
      return new Object[] { g22utils, image };
    }

    public Map<G22Analyzer, Object> analyzerResults = syncMap();

    static public Object calculating;

    public Object callAnalyzer(long analyzerID) {
      var analyzer = getConcept(g22utils.concepts(), G22Analyzer.class, analyzerID);
      if (analyzer == null)
        throw fail("Analyzer with ID " + analyzerID + " not found");
      return callAnalyzer(analyzer);
    }

    public Object callAnalyzer(G22Analyzer analyzer) {
      return analyzer.compileForAutoRun().get(this);
    }
  }

  static public class RunResultWithTimestamps<A> extends OKOrError<A> {

    final public RunResultWithTimestamps<A> setStarted(Timestamp started) {
      return started(started);
    }

    public RunResultWithTimestamps<A> started(Timestamp started) {
      this.started = started;
      return this;
    }

    final public Timestamp getStarted() {
      return started();
    }

    public Timestamp started() {
      return started;
    }

    public Timestamp started;

    final public RunResultWithTimestamps<A> setEnded(Timestamp ended) {
      return ended(ended);
    }

    public RunResultWithTimestamps<A> ended(Timestamp ended) {
      this.ended = ended;
      return this;
    }

    final public Timestamp getEnded() {
      return ended();
    }

    public Timestamp ended() {
      return ended;
    }

    public Timestamp ended;

    final public RunResultWithTimestamps<A> setPrintOutput(CharSequence printOutput) {
      return printOutput(printOutput);
    }

    public RunResultWithTimestamps<A> printOutput(CharSequence printOutput) {
      this.printOutput = printOutput;
      return this;
    }

    final public CharSequence getPrintOutput() {
      return printOutput();
    }

    public CharSequence printOutput() {
      return printOutput;
    }

    public CharSequence printOutput;

    public RunResultWithTimestamps<A> run(IF0<A> f) {
      return setPrintOutput(hijackPrint_tee(new Runnable() {

        public void run() {
          try {
            started(tsNow());
            copyFrom(okOrError(f));
            ended(tsNow());
          } catch (Exception __e) {
            throw rethrow(__e);
          }
        }

        public String toString() {
          return "started(tsNow());\r\n      copyFrom(okOrError(f));\r\n      ended(tsNow());";
        }
      }));
    }

    public boolean hasRun() {
      return ended != null;
    }

    public OKOrError result() {
      return this;
    }

    public Duration duration() {
      return ended.minusAsDuration(started);
    }
  }

  static public class FieldVar<A> extends VarWithNotify<A> {

    public IHasChangeListeners containingObject;

    public String fieldName;

    public IF0<A> getter;

    public IVF1<A> setter;

    public FieldVar(IHasChangeListeners containingObject, String fieldName, IF0<A> getter, IVF1<A> setter) {
      this.setter = setter;
      this.getter = getter;
      this.fieldName = fieldName;
      this.containingObject = containingObject;
      containingObject.onChangeAndNow(() -> _updateFromObject());
    }

    public void _updateFromObject() {
      set(getter.get());
    }

    public void fireChange() {
      setter.get(get());
      super.fireChange();
    }

    public FieldVar<A> onChange(IVF1<A> r) {
      if (r != null)
        onChange(() -> r.get(get()));
      return this;
    }
  }

  static public class ReliableSingleThread implements Runnable {

    public boolean _isTransient() {
      return true;
    }

    public Object runnable;

    public String name = "Single Thread";

    public boolean cancelBeforeTrigger = false;

    public boolean waitBetweenCancelAndTrigger = false;

    public F0<AutoCloseable> enter;

    public int cancelTimeOut = 10000;

    public boolean trigger = false;

    public Thread thread;

    public WeakReference<Thread> threadBeingCancelled;

    public List<Runnable> inserts = syncL();

    public ReliableSingleThread(Object runnable) {
      this.runnable = runnable;
    }

    public void trigger() {
      go();
    }

    synchronized public void go() {
      if (cancelBeforeTrigger)
        cancelAndPossiblyWait();
      trigger = true;
      if (!running()) {
        AutoCloseable __1 = callF(enter);
        try {
          thread = startThread(name, new Runnable() {

            public void run() {
              try {
                AutoCloseable __2 = callF(enter);
                try {
                  _run();
                } finally {
                  _close(__2);
                }
              } catch (Exception __e) {
                throw rethrow(__e);
              }
            }

            public String toString() {
              return "temp callF(enter);\r\n        _run();";
            }
          });
        } finally {
          _close(__1);
        }
      }
    }

    public void run() {
      go();
    }

    public void get() {
      go();
    }

    synchronized public boolean running() {
      return thread != null;
    }

    public void triggerAndWait() {
      trigger();
      waitUntilDone();
    }

    public void waitUntilDone() {
      while (running()) sleep(1);
    }

    public void _run() {
      try {
        while (licensed()) {
          Thread oldThread;
          synchronized (this) {
            var currentInserts = syncGetAndClear(inserts);
            pcallFAll(currentInserts);
            if (!trigger) {
              thread = null;
              break;
            }
            oldThread = getWeakRef(threadBeingCancelled);
            trigger = false;
          }
          if (oldThread != null && oldThread != currentThread())
            oldThread.join(cancelTimeOut);
          pcallF(runnable);
        }
      } catch (Exception __e) {
        throw rethrow(__e);
      }
    }

    synchronized public void cancel() {
      if (thread == null)
        return;
      threadBeingCancelled = new WeakReference(thread);
      cancelAndInterruptThread(thread);
      thread = null;
    }

    public void cancelAndWait() {
      Thread _thread;
      synchronized (this) {
        if (thread == null)
          return;
        _thread = thread;
        threadBeingCancelled = new WeakReference(thread);
        thread = null;
      }
      cancelAndInterruptThread(_thread);
    }

    public void cancelAndTrigger() {
      cancelAndPossiblyWait();
      trigger();
    }

    synchronized public boolean triggered() {
      return trigger;
    }

    public void cleanMeUp() {
      cancel();
    }

    public ReliableSingleThread cancelBeforeTrigger() {
      cancelBeforeTrigger = true;
      return this;
    }

    public void cancelAndPossiblyWait() {
      if (waitBetweenCancelAndTrigger)
        cancel();
    }

    public void insert(Runnable r) {
      inserts.add(r);
      trigger();
    }

    synchronized public boolean hasThread() {
      return thread != null;
    }
  }

  static public class RestartableCountdown implements AutoCloseable {

    public java.util.Timer timer;

    public long targetTime;

    public long totalSleepTime;

    synchronized public void setTargetTime(long targetTime, Runnable action) {
      if (targetTime <= 0)
        stop();
      else if (targetTime != this.targetTime) {
        start(targetTime - sysNow(), action);
        this.targetTime = targetTime;
      }
    }

    synchronized public void start(long delayMS, Object action) {
      stop();
      if (delayMS <= 0) {
        startThread(new Runnable() {

          public void run() {
            try {
              callF(action);
            } catch (Exception __e) {
              throw rethrow(__e);
            }
          }

          public String toString() {
            return "callF(action);";
          }
        });
      } else {
        totalSleepTime += delayMS;
        timer = doLater_daemon(delayMS, action);
        targetTime = sysNow() + delayMS;
      }
    }

    public void start(double delaySeconds, Object action) {
      start(toMS(delaySeconds), action);
    }

    synchronized public void stop() {
      cancelTimer(timer);
      timer = null;
      targetTime = 0;
    }

    public void close() {
      stop();
    }
  }

  static public class VarMatches extends WrappedMap<String, String> {

    public VarMatches() {
      super(new LinkedHashMap());
    }

    public VarMatches(Map<String, String> map) {
      this();
      main.putAll(this, map);
    }
  }

  static public interface IF1_IntToInt {

    public int get(int i);
  }

  abstract static public class ImageSurfaceMouseHandler extends MouseAdapter implements AutoCloseable {

    public ImageSurface is;

    public void register(ImageSurface is) {
      this.is = is;
      is.tools.add(this);
      is.addMouseListener(this);
      is.addMouseMotionListener(this);
    }

    public void close() {
      try {
        if (is == null)
          return;
        is.tools.remove(this);
        is.removeMouseListener(this);
        is.removeMouseMotionListener(this);
        is = null;
      } catch (Exception __e) {
        throw rethrow(__e);
      }
    }

    public Pt getPt(MouseEvent e) {
      return toPt(getPoint(e));
    }

    public Point getPoint(MouseEvent e) {
      return new Point((int) (e.getX() / is.getZoomX()), (int) (e.getY() / is.getZoomY()));
    }

    public ImageSurface getImageSurface() {
      return is;
    }
  }

  public enum G22ScriptMode {

    edit, saved, autoRunnable
  }

  public interface RunnableWithExceptions {

    public void run() throws Exception;
  }

  static public class LeftArrowScriptAutoCompleter extends Meta implements IFieldsToList {

    public GazelleV_LeftArrowScriptParser parser;

    public LeftArrowScriptAutoCompleter() {
    }

    public LeftArrowScriptAutoCompleter(GazelleV_LeftArrowScriptParser parser) {
      this.parser = parser;
    }

    public String toString() {
      return shortClassName_dropNumberPrefix(this) + "(" + parser + ")";
    }

    public Object[] _fieldsToList() {
      return new Object[] { parser };
    }

    public List<String> tok;

    public CharInToken cursor;

    public String typedCharacters;

    public ScoredStringSearcher searcher;

    final public LeftArrowScriptAutoCompleter setG22utils(G22Utils g22utils) {
      return g22utils(g22utils);
    }

    public LeftArrowScriptAutoCompleter g22utils(G22Utils g22utils) {
      this.g22utils = g22utils;
      return this;
    }

    final public G22Utils getG22utils() {
      return g22utils();
    }

    public G22Utils g22utils() {
      return g22utils;
    }

    public G22Utils g22utils;

    public TreeMap<Integer, Collection<String>> knowVarsByTokenIdx = new TreeMap();

    public LeftArrowScriptAutoCompleter(G22Utils g22utils, GazelleV_LeftArrowScriptParser parser) {
      this.parser = parser;
      this.g22utils = g22utils;
    }

    public void seekEnd(String text) {
      seek(text, l(text));
    }

    public void seek(String text, int iChar) {
      if (tok != null)
        throw fail("Don't reuse instance");
      parser.setText(text);
      parser.init();
      tok = parser.tok;
      cursor = charIndexToCharInToken(tok, iChar);
      if (even(cursor.iTok) && cursor.iTok > 0 && cursor.iChar == 0) {
        cursor.iTok--;
        cursor.iChar = l(token());
      }
      if (cursor.iTok > 1 && cursor.iChar == 0 && empty(space())) {
        cursor.iTok -= 2;
        cursor.iChar = l(token());
      }
      typedCharacters = takeFirst(cursor.token(), cursor.iChar);
      parser.onKnownVarsSnapshot(knownVars -> knowVarsByTokenIdx.put(parser.tokIdx(), cloneKeys(knownVars)));
      try {
        parser.parse();
      } catch (Throwable __e) {
        print(exceptionToStringShort(__e));
      }
    }

    public String typedCharacters() {
      return typedCharacters;
    }

    public String space() {
      return get(tok, cursor.iTok - 1);
    }

    public String token() {
      return get(tok, cursor.iTok);
    }

    public String prevToken() {
      return get(tok, cursor.iTok - 2);
    }

    public boolean beginningOfCmd() {
      return eqOneOf(prevToken(), ";", "{", "}") || containsNewLine(space());
    }

    public Collection<String> getCompletions() {
      return searcher().get_transformListWithinScore(__1 -> stringsSortedByLength(__1));
    }

    public ScoredStringSearcher searcher() {
      searcher = new ScoredStringSearcher(typedCharacters);
      searcher.uniquify(true);
      if (empty(typedCharacters))
        searcher.returnAll = true;
      String prev = prevToken();
      if (scaffoldingEnabled(this))
        printVars("LeftArrowScriptAutoCompleter", "beginningOfCmd", beginningOfCmd(), "prev", prev, "cursor", cursor, "typedCharacters", typedCharacters, "globalClassNames", l(parser.globalClassNames()));
      if (beginningOfCmd() || !isIdentifier(prev) || eqOneOf(prev, "if", "else"))
        addToSearcher(globalMethodNames());
      addToSearcher(keys(parser.globalClassNames()));
      addToSearcher(predefinedExpressions());
      Collection<String> knownVars = floorValue(knowVarsByTokenIdx, cursor.iTok);
      addToSearcher(knownVars);
      return searcher;
    }

    public Collection<String> predefinedExpressions() {
      return ll("true", "false", "null");
    }

    transient public IF0<Collection<String>> globalMethodNames;

    public Collection<String> globalMethodNames() {
      return globalMethodNames != null ? globalMethodNames.get() : globalMethodNames_base();
    }

    final public Collection<String> globalMethodNames_fallback(IF0<Collection<String>> _f) {
      return _f != null ? _f.get() : globalMethodNames_base();
    }

    public Collection<String> globalMethodNames_base() {
      return concatMap(__75 -> methodNames(__75), parser.functionContainers);
    }

    public void addToSearcher(String... l) {
      addToSearcher(asList(l));
    }

    public void addToSearcher(Iterable<String> l) {
      for (var s : unnullForIteration(l)) if (!eq(s, typedCharacters))
        searcher.add(s);
    }
  }

  static public class MinimalChain<A> implements Iterable<A> {

    public A element;

    public MinimalChain<A> next;

    public MinimalChain() {
    }

    public MinimalChain(A element) {
      this.element = element;
    }

    public MinimalChain(A element, MinimalChain<A> next) {
      this.next = next;
      this.element = element;
    }

    public String toString() {
      return str(toList());
    }

    public ArrayList<A> toList() {
      ArrayList<A> l = new ArrayList();
      MinimalChain<A> c = this;
      while (c != null) {
        l.add(c.element);
        c = c.next;
      }
      return l;
    }

    public void setElement(A a) {
      element = a;
    }

    public void setNext(MinimalChain<A> next) {
      this.next = next;
    }

    public Iterator<A> iterator() {
      return toList().iterator();
    }

    public A get() {
      return element;
    }
  }

  static public class PersistableOKOrError<A> implements IF0<A> {

    public A value;

    final public PersistableThrowable getError() {
      return error();
    }

    public PersistableThrowable error() {
      return error;
    }

    public PersistableThrowable error;

    public PersistableOKOrError() {
    }

    public PersistableOKOrError(A value) {
      this.value = value;
    }

    public PersistableOKOrError(boolean dummy, PersistableThrowable error) {
      this.error = error;
      assertNotNull(error);
    }

    final public boolean isOK() {
      return ok();
    }

    public boolean ok() {
      return error == null;
    }

    public String toString() {
      return ok() ? str(value) : "Error: " + str(error);
    }

    public A get() {
      return !ok() ? null : value;
    }

    public A getMandatory() {
      if (!ok())
        throw error.asRuntimeException();
      return value;
    }

    static public <A> PersistableOKOrError<A> ok(A a) {
      return new PersistableOKOrError(a);
    }

    static public PersistableOKOrError error(PersistableThrowable error) {
      return new PersistableOKOrError(false, error);
    }
  }

  static public class RSTADummyParser extends org.fife.ui.rsyntaxtextarea.parser.AbstractParser {

    final public Pair<String, List<Error>> getErrors() {
      return errors();
    }

    public Pair<String, List<Error>> errors() {
      return errors;
    }

    public Pair<String, List<Error>> errors;

    static public class Error {

      final public Error setStart(LineAndColumn start) {
        return start(start);
      }

      public Error start(LineAndColumn start) {
        this.start = start;
        return this;
      }

      final public LineAndColumn getStart() {
        return start();
      }

      public LineAndColumn start() {
        return start;
      }

      public LineAndColumn start;

      final public Error setEnd(LineAndColumn end) {
        return end(end);
      }

      public Error end(LineAndColumn end) {
        this.end = end;
        return this;
      }

      final public LineAndColumn getEnd() {
        return end();
      }

      public LineAndColumn end() {
        return end;
      }

      public LineAndColumn end;

      final public Error setMsg(String msg) {
        return msg(msg);
      }

      public Error msg(String msg) {
        this.msg = msg;
        return this;
      }

      final public String getMsg() {
        return msg();
      }

      public String msg() {
        return msg;
      }

      public String msg;
    }

    @Override
    public org.fife.ui.rsyntaxtextarea.parser.ParseResult parse(RSyntaxDocument doc, String style) {
      var result = new org.fife.ui.rsyntaxtextarea.parser.DefaultParseResult(this);
      try {
        var p = this.errors;
        if (p == null)
          return result;
        String src = p.a;
        var errors = p.b;
        if (empty(errors))
          return result;
        String text = doc.getText(0, doc.getLength());
        if (!eq(text, src)) {
          print("RSTADummyParser: Wrong text");
          return result;
        }
        for (Error e : errors) {
          LineAndColumn start = e.start;
          LineAndColumn end = e.end;
          int lineStart = lineNrToCharIndex(text, start.line);
          int lineLength = lengthOfLine(text, start.line - 1);
          result.addNotice(new org.fife.ui.rsyntaxtextarea.parser.DefaultParserNotice(this, e.msg, start.line - 1, lineStart, lineLength));
        }
      } catch (Throwable __e) {
        printStackTrace(__e);
      }
      return result;
    }

    public void setErrors(String text, List<Error> errors, RSyntaxTextArea textArea) {
      this.errors = pair(text, errors);
      {
        swing(() -> {
          textArea.forceReparsing(RSTADummyParser.this);
        });
      }
    }

    public void install(RSyntaxTextArea textArea) {
      swing(() -> {
        textArea.addParser(RSTADummyParser.this);
      });
    }
  }

  public interface IPersistenceInfo {

    public Map _persistenceInfo();
  }

  static public class IntRange {

    public int start, end;

    public IntRange() {
    }

    public IntRange(int start, int end) {
      this.end = end;
      this.start = start;
    }

    public IntRange(IntRange r) {
      start = r.start;
      end = r.end;
    }

    public boolean equals(Object o) {
      return stdEq2(this, o);
    }

    public int hashCode() {
      return stdHash2(this);
    }

    final public int length() {
      return end - start;
    }

    final public boolean empty() {
      return start >= end;
    }

    final public boolean isEmpty() {
      return start >= end;
    }

    static public String _fieldOrder = "start end";

    public String toString() {
      return "[" + start + ";" + end + "]";
    }
  }

  static public class Average {

    final public double getSum() {
      return sum();
    }

    public double sum() {
      return sum;
    }

    public double sum;

    final public double getN() {
      return n();
    }

    public double n() {
      return n;
    }

    public double n;

    public void add(double d) {
      ++n;
      sum += d;
    }

    public void add(double d, double weight) {
      n += weight;
      sum += d * weight;
    }

    final public double avg() {
      return get();
    }

    final public double average() {
      return get();
    }

    final public double getAverage() {
      return get();
    }

    public double get() {
      return doubleRatio(sum, n);
    }

    public boolean isEmpty() {
      return n == 0;
    }

    public String toString() {
      return get() + " (n=" + n + ")";
    }

    public void clear() {
      n = 0;
      sum = 0;
    }
  }

  static public class TreeMultiMap<A, B> extends MultiMap<A, B> {

    public TreeMultiMap() {
      super(true);
    }

    public TreeMultiMap(MultiMap<A, B> map) {
      this();
      putAll(map);
    }
  }

  static public class Flag implements Runnable {

    public boolean up = false;

    public synchronized boolean raise() {
      if (!up) {
        up = true;
        notifyAll();
        return true;
      } else
        return false;
    }

    public synchronized void waitUntilUp() {
      try {
        while (!up) {
          wait();
        }
      } catch (Exception __e) {
        throw rethrow(__e);
      }
    }

    public boolean waitUntilUp(double timeout) {
      if (timeout == infinity()) {
        waitUntilUp();
        return isUp();
      } else
        return waitUntilUp(toMS(timeout));
    }

    public synchronized boolean waitUntilUp(long timeout) {
      try {
        if (!up) {
          wait(timeout);
        }
        return isUp();
      } catch (Exception __e) {
        throw rethrow(__e);
      }
    }

    public synchronized boolean isUp() {
      return up;
    }

    public boolean get() {
      return isUp();
    }

    public String toString() {
      return isUp() ? "up" : "down";
    }

    public void waitForThisOr(Flag otherFlag) {
      try {
        while (!isUp() && !otherFlag.isUp()) Thread.sleep(50);
      } catch (Exception __e) {
        throw rethrow(__e);
      }
    }

    public void run() {
      raise();
    }
  }

  static public class ClearForAutoRun<A> extends Var<A> {

    public ClearForAutoRun() {
    }

    public ClearForAutoRun(A code) {
      super(code);
    }
  }

  static public class G22JavaObjectVisualizer implements Swingable, IFieldsToList {

    public G22Utils g22utils;

    public G22JavaObjectVisualizer() {
    }

    public G22JavaObjectVisualizer(G22Utils g22utils) {
      this.g22utils = g22utils;
    }

    public String toString() {
      return shortClassName_dropNumberPrefix(this) + "(" + g22utils + ")";
    }

    public Object[] _fieldsToList() {
      return new Object[] { g22utils };
    }

    final public G22JavaObjectVisualizer setWithTypeAndTime(boolean withTypeAndTime) {
      return withTypeAndTime(withTypeAndTime);
    }

    public G22JavaObjectVisualizer withTypeAndTime(boolean withTypeAndTime) {
      this.withTypeAndTime = withTypeAndTime;
      return this;
    }

    final public boolean getWithTypeAndTime() {
      return withTypeAndTime();
    }

    public boolean withTypeAndTime() {
      return withTypeAndTime;
    }

    public boolean withTypeAndTime = true;

    final public G22JavaObjectVisualizer setSingleLineLayout(boolean singleLineLayout) {
      return singleLineLayout(singleLineLayout);
    }

    public G22JavaObjectVisualizer singleLineLayout(boolean singleLineLayout) {
      this.singleLineLayout = singleLineLayout;
      return this;
    }

    final public boolean getSingleLineLayout() {
      return singleLineLayout();
    }

    public boolean singleLineLayout() {
      return singleLineLayout;
    }

    public boolean singleLineLayout = false;

    final public G22JavaObjectVisualizer setMaxElements(int maxElements) {
      return maxElements(maxElements);
    }

    public G22JavaObjectVisualizer maxElements(int maxElements) {
      this.maxElements = maxElements;
      return this;
    }

    final public int getMaxElements() {
      return maxElements();
    }

    public int maxElements() {
      return maxElements;
    }

    public int maxElements = 1000;

    final public G22JavaObjectVisualizer setHorizontal(boolean horizontal) {
      return horizontal(horizontal);
    }

    public G22JavaObjectVisualizer horizontal(boolean horizontal) {
      this.horizontal = horizontal;
      return this;
    }

    final public boolean getHorizontal() {
      return horizontal();
    }

    public boolean horizontal() {
      return horizontal;
    }

    public boolean horizontal = false;

    public Set seen = identityHashSet();

    final public G22JavaObjectVisualizer setObject(Object object) {
      return object(object);
    }

    public G22JavaObjectVisualizer object(Object object) {
      this.object = object;
      return this;
    }

    final public Object getObject() {
      return object();
    }

    public Object object() {
      return object;
    }

    transient public Object object;

    final public G22JavaObjectVisualizer setNanos(long nanos) {
      return nanos(nanos);
    }

    public G22JavaObjectVisualizer nanos(long nanos) {
      this.nanos = nanos;
      return this;
    }

    final public long getNanos() {
      return nanos();
    }

    public long nanos() {
      return nanos;
    }

    transient public long nanos = -1;

    transient public LinkedHashMap<String, Object> properties = new LinkedHashMap();

    public G22JavaObjectVisualizer(G22Utils g22utils, Object object) {
      this.object = object;
      this.g22utils = g22utils;
    }

    public String objectInfos() {
      List<String> infos = new ArrayList();
      infos.add(str(shortClassName(object)));
      for (var __0 : _entrySet(properties)) {
        var key = __0.getKey();
        var val = __0.getValue();
        String s = n2OrStrOrNull(val);
        if (nempty(s))
          infos.add(key + " " + s);
      }
      return joinNemptiesWithComma(infos);
    }

    public transient JComponent visualize_cache;

    public JComponent visualize() {
      if (visualize_cache == null)
        visualize_cache = visualize_load();
      return visualize_cache;
    }

    public JComponent visualize_load() {
      return markVisualizer(this, visualize_impl());
    }

    public JComponent visualize_impl() {
      JComponent c = visualizeObject(object);
      if (withTypeAndTime) {
        String type = objectInfos();
        String timeDesc = nanos < 0 ? "" : formatElapsedTimeWithAppropriateUnit(nanosToSeconds(nanos));
        c = northAndCenterWithMargins(westAndEastWithMargin(withLabel("Type:", jlabel(type)), empty(timeDesc) ? jpanel() : withLabel("Execution time:", jlabel(timeDesc))), c);
      }
      return c;
    }

    public JComponent visualizeObject(Object object) {
      return mainVisualizer().visualize(object);
    }

    public ObjectVisualizer mainVisualizer() {
      return new ObjectVisualizer().recurse(true).bigFont(true).horizontal(horizontal);
    }

    public class ObjectVisualizer {

      final public ObjectVisualizer setRecurse(boolean recurse) {
        return recurse(recurse);
      }

      public ObjectVisualizer recurse(boolean recurse) {
        this.recurse = recurse;
        return this;
      }

      final public boolean getRecurse() {
        return recurse();
      }

      public boolean recurse() {
        return recurse;
      }

      public boolean recurse = false;

      final public ObjectVisualizer setBigFont(boolean bigFont) {
        return bigFont(bigFont);
      }

      public ObjectVisualizer bigFont(boolean bigFont) {
        this.bigFont = bigFont;
        return this;
      }

      final public boolean getBigFont() {
        return bigFont();
      }

      public boolean bigFont() {
        return bigFont;
      }

      public boolean bigFont = false;

      final public ObjectVisualizer setHorizontal(boolean horizontal) {
        return horizontal(horizontal);
      }

      public ObjectVisualizer horizontal(boolean horizontal) {
        this.horizontal = horizontal;
        return this;
      }

      final public boolean getHorizontal() {
        return horizontal();
      }

      public boolean horizontal() {
        return horizontal;
      }

      public boolean horizontal = false;

      public ObjectVisualizer subVisualizer() {
        return new ObjectVisualizer().horizontal(!horizontal);
      }

      public JComponent makeBig(JComponent c) {
        if (bigFont)
          return fontSizePlus(10, c);
        return c;
      }

      public JComponent visualize(Object object) {
        try {
          return visualize2(object);
        } catch (Throwable e) {
          return jErrorView(new RuntimeException("Visualization error", e));
        }
      }

      public JComponent visualize2(Object object) {
        if (object instanceof Throwable)
          return jErrorView((Throwable) object);
        if (object == null || eq(object, ""))
          return jpanel();
        if (object instanceof Swingable)
          object = ((Swingable) object).visualize();
        if (object instanceof JComponent && getParent((JComponent) object) == null)
          return ((JComponent) object);
        if (object instanceof Integer)
          object = toLong((Integer) object);
        if (object instanceof Long)
          return makeBig(jcenteredLabel(n2((Long) object)));
        if (object instanceof Number)
          return makeBig(jcenterNarrowLabel(str((Number) object)));
        if (object instanceof Pair) {
          if (horizontal)
            return jcenteredline(jlabel("<"), visualize(((Pair) object).a), jlabel(","), visualize(((Pair) object).b), jlabel(">"));
          else
            return vstackWithSpacing(visualize(((Pair) object).a), visualize(((Pair) object).b));
        }
        if (object instanceof MakesBufferedImage)
          object = toBufferedImage((MakesBufferedImage) object);
        if (object instanceof BufferedImage) {
          var is = g22utils.stdImageSurface((BufferedImage) object);
          if (!recurse)
            is.setAutoZoomToDisplay(false);
          return jscroll_centered_borderless(is);
        }
        if (recurse) {
          if (object instanceof MultiMap) {
            propertyLength(l((MultiMap) object));
            propertyKeyCount(((MultiMap) object).keyCount());
            object = multiMapToMapPairs((MultiMap) object);
          }
          if (object instanceof MultiSetMap) {
            propertyLength(l((MultiSetMap) object));
            propertyKeyCount(((MultiSetMap) object).keyCount());
            object = multiSetMapToMapPairs((MultiSetMap) object);
          }
          if (object instanceof Map) {
            propertyLength(l((Map) object));
            object = mapToPairs((Map) object);
          }
          if (object instanceof Collection) {
            propertyLength(l((Collection) object));
            var sub = subVisualizer();
            var elements = map(cloneTakeFirst(maxElements, ((Collection) object)), element -> sub.visualize(element));
            return jscroll_centered_borderless(horizontal ? hstackWithSpacing(elements) : vstackWithSpacing(elements));
          }
          if (isArray(object))
            propertyLength(arrayLength(object));
        }
        if (object instanceof String) {
          propertyLength(l((String) object));
        }
        String string = str(object);
        if (containsNewLine(string))
          return jscroll_borderless(wordWrapTypeWriterTextArea(string));
        return jcenterNarrowLabel(shorten(string));
      }
    }

    public void propertyLength(int l) {
      properties.put("size", l);
    }

    public void propertyKeyCount(int l) {
      properties.put("keys", l);
    }
  }

  static public class Stringifier_ToString implements IStringifier {

    public String toString(Object o) {
      return str(o);
    }
  }

  public interface IPartialStringifier<A> {

    public String toStringOpt(A o);
  }

  static public class G22TypeDesc {

    public String exactClassName;

    public Set<String> implementedClassNames;
  }

  static public List<String> _stickyLibs_1400546 = ll("#1400546", "#1400547", "#1400548");

  static public class MetaWithChangeListeners extends Meta implements IHasChangeListeners, ChangeTriggerable {

    transient public Set<Runnable> onChange;

    public MetaWithChangeListeners onChange(Runnable r) {
      onChange = createOrAddToSyncLinkedHashSet(onChange, r);
      return this;
    }

    public MetaWithChangeListeners removeChangeListener(Runnable r) {
      main.remove(onChange, r);
      return this;
    }

    public void change() {
      if (onChange != null)
        for (var listener : onChange) pcallF_typed(listener);
    }
  }

  static public class G22ScriptResultPanel implements Swingable {

    public JTabbedPane tabs;

    public JFastLogView_noWrap logView = jFastLogView_noWrap();

    public SingleComponentPanel scpResult = singleComponentPanel();

    public transient JComponent visualize_cache;

    public JComponent visualize() {
      if (visualize_cache == null)
        visualize_cache = visualize_load();
      return visualize_cache;
    }

    public JComponent visualize_load() {
      return markVisualizer(this, visualize_impl());
    }

    public JComponent visualize_impl() {
      return tabs = jtabs("Result", scpResult, "Log", jscroll_borderless(logView));
    }
  }

  static public class Seconds implements Comparable<Seconds>, IFieldsToList {

    public double seconds;

    public Seconds() {
    }

    public Seconds(double seconds) {
      this.seconds = seconds;
    }

    public boolean equals(Object o) {
      if (!(o instanceof Seconds))
        return false;
      Seconds __1 = (Seconds) o;
      return seconds == __1.seconds;
    }

    public int hashCode() {
      int h = -660217249;
      h = boostHashCombine(h, _hashCode(seconds));
      return h;
    }

    public Object[] _fieldsToList() {
      return new Object[] { seconds };
    }

    final public double get() {
      return seconds();
    }

    final public double getDouble() {
      return seconds();
    }

    public double seconds() {
      return seconds;
    }

    public String toString() {
      return formatDouble(seconds, 3) + " s";
    }

    public int compareTo(Seconds s) {
      return cmp(seconds, s.seconds);
    }

    public Seconds div(double x) {
      return new Seconds(get() / x);
    }

    public Seconds minus(Seconds x) {
      return new Seconds(get() - x.get());
    }
  }

  static public interface IVar<A> extends IF0<A> {

    public void set(A a);

    public A get();

    default public Class<A> getType() {
      return null;
    }

    default public boolean has() {
      return get() != null;
    }

    default public void clear() {
      set(null);
    }
  }

  public interface IBackgroundProcess extends AutoCloseable {

    public IBackgroundProcess setInterruptAction(Runnable action);
  }

  static public class WrappedMap<A, B> extends AbstractMap<A, B> {

    public Map<A, B> map;

    public WrappedMap() {
    }

    public WrappedMap(Map<A, B> map) {
      this.map = map;
    }

    public B get(Object key) {
      return map.get(key);
    }

    public B put(A key, B value) {
      return map.put(key, value);
    }

    public boolean containsKey(Object key) {
      return map.containsKey(key);
    }

    public Set<Map.Entry<A, B>> entrySet() {
      return map.entrySet();
    }
  }

  static public class ScoredStringSearcher extends ScoredSearcher_stable<String> {

    public Set<String> seen;

    public ScoredStringSearcher() {
    }

    public ScoredStringSearcher(String query, Object... __) {
      super(query);
    }

    public ScoredStringSearcher uniquify(boolean b) {
      seen = b ? new HashSet() : null;
      return this;
    }

    final public void add(String s) {
      put(s);
    }

    public void put(String s) {
      if (seen == null || seen.add(s))
        put(s, s);
    }

    public void addAll(Iterable<String> l) {
      for (var s : unnullForIteration(l)) add(s);
    }

    public void addAll(String... l) {
      addAll(asList(l));
    }
  }

  static public interface ISetter<A> {

    public void set(A a);
  }

  static public class JavaXPeepholeShortener implements IFieldsToList {

    public List<String> tok;

    public JavaXPeepholeShortener() {
    }

    public JavaXPeepholeShortener(List<String> tok) {
      this.tok = tok;
    }

    public String toString() {
      return shortClassName_dropNumberPrefix(this) + "(" + tok + ")";
    }

    public Object[] _fieldsToList() {
      return new Object[] { tok };
    }

    public void run() {
      try {
        jreplace(tok, "<quoted>, <id>", "+$3", (_tok, nIdx) -> eq(unquote(_get(tok, nIdx + 1)), _get(tok, nIdx + 5)));
      } catch (Exception __e) {
        throw rethrow(__e);
      }
    }
  }

  static public class CharInToken implements IFieldsToList {

    static final public String _fieldOrder = "tok iTok iChar";

    public List<String> tok;

    public int iTok;

    public int iChar;

    public CharInToken() {
    }

    public CharInToken(List<String> tok, int iTok, int iChar) {
      this.iChar = iChar;
      this.iTok = iTok;
      this.tok = tok;
    }

    public boolean equals(Object o) {
      if (!(o instanceof CharInToken))
        return false;
      CharInToken __1 = (CharInToken) o;
      return eq(tok, __1.tok) && iTok == __1.iTok && iChar == __1.iChar;
    }

    public int hashCode() {
      int h = 2081721214;
      h = boostHashCombine(h, _hashCode(tok));
      h = boostHashCombine(h, _hashCode(iTok));
      h = boostHashCombine(h, _hashCode(iChar));
      return h;
    }

    public Object[] _fieldsToList() {
      return new Object[] { tok, iTok, iChar };
    }

    public String token() {
      return get(tok, iTok);
    }

    public String toString() {
      return renderRecordVars("CharInToken", "iTok", iTok, "iChar", iChar, "token", token());
    }
  }

  static abstract public class LiveValue<A> implements IF0WithChangeListeners<A> {

    abstract public Class<A> getType();

    public abstract A get();
  }

  public interface ChangeTriggerable {

    public void change();
  }

  static public interface IHasGlobalID {

    public GlobalID globalID();
  }

  public interface IHasChangeListeners {

    public IHasChangeListeners onChange(Runnable r);

    public IHasChangeListeners removeChangeListener(Runnable r);

    default public IHasChangeListeners onChangeAndNow(Runnable l) {
      onChange(l);
      callF(l);
      return this;
    }
  }

  static public class VarWithNotify<A> extends Var<A> implements IVarWithNotify<A> {

    transient public Set<Runnable> onChange;

    public VarWithNotify<A> onChange(Runnable r) {
      onChange = createOrAddToSyncLinkedHashSet(onChange, r);
      return this;
    }

    public VarWithNotify<A> removeChangeListener(Runnable r) {
      main.remove(onChange, r);
      return this;
    }

    public void fireChange() {
      if (onChange != null)
        for (var listener : onChange) pcallF_typed(listener);
    }

    public VarWithNotify() {
    }

    public VarWithNotify(A a) {
      super(a);
    }

    public void set(A a) {
      A v = get();
      if (eq(v, a)) {
        return;
      }
      synchronized (this) {
        this.v = a;
        notifyAll();
      }
      fireChange();
    }
  }

  static public class JFastLogView_noWrap extends JComponent implements Scrollable {

    public List<String> lines = syncList();

    public boolean endsWithNewLine, verbose;

    public Dimension getPreferredScrollableViewportSize() {
      return getPreferredSize();
    }

    public int getScrollableUnitIncrement(Rectangle visibleRect, int orientation, int direction) {
      return 20;
    }

    public int getScrollableBlockIncrement(Rectangle visibleRect, int orientation, int direction) {
      return (direction == SwingConstants.HORIZONTAL ? visibleRect.width : visibleRect.height) * 5 / 6;
    }

    public boolean getScrollableTracksViewportWidth() {
      return false;
    }

    public boolean getScrollableTracksViewportHeight() {
      return false;
    }

    public void paint(Graphics g) {
      int w = getWidth(), h = getHeight();
      g.setColor(getBackground());
      g.fillRect(0, 0, w, h);
      g.setColor(getForeground());
      FontMetrics fm = componentFontMetrics(this);
      int fh = fm.getHeight();
      Rectangle clip = g.getClipBounds();
      int start, end;
      if (clip == null) {
        start = 0;
        end = l(lines);
      } else {
        start = max(0, clip.y / fh);
        end = min(l(lines), idiv_ceil(clip.y + clip.height, fh));
      }
      int y = fm.getAscent() + start * fh;
      for (int i = start; i < end; i++) {
        String s = get(lines, i);
        if (s != null)
          g.drawString(s, 0, y);
        y += fh;
      }
    }

    public Dimension getPreferredSize() {
      FontMetrics fm = componentFontMetrics(this);
      if (fm == null)
        return new Dimension(50, 50);
      int fh = fm.getHeight();
      int w = 0;
      for (int i = 0; i < l(lines); i++) {
        String s = get(lines, i);
        w = max(w, fm.stringWidth(unnull(s)));
      }
      return new Dimension(w, fh * l(lines));
    }

    public JFastLogView_noWrap() {
    }

    public JFastLogView_noWrap(String text) {
      setText(text);
    }

    {
      componentPopupMenuItem(this, "Copy full text", new Runnable() {

        public void run() {
          try {
            copyFullText();
          } catch (Exception __e) {
            throw rethrow(__e);
          }
        }

        public String toString() {
          return "copyFullText();";
        }
      });
    }

    public boolean setLines(Collection<String> lines) {
      List<String> newList = asSyncList(lines);
      if (eq(this.lines, newList))
        return false;
      this.lines = newList;
      _revalidate(this);
      return true;
    }

    public boolean setText(String text) {
      endsWithNewLine = endsWithNewLine(text);
      return setLines(lines(text));
    }

    public void append(String text) {
      if (nempty(text))
        setText(getText() + text);
    }

    public String getText() {
      return lines_rtrimIf(!endsWithNewLine, cloneList(lines));
    }

    public void copyFullText() {
      copyTextToClipboard(getText());
    }
  }

  static public class FunctionCall implements Transformable, IFieldsToList {

    public Object function;

    public Object[] args;

    public FunctionCall() {
    }

    public Object[] _fieldsToList() {
      return new Object[] { function, args };
    }

    static public String _fieldOrder = "function args";

    public FunctionCall(Object function, Object... args) {
      this.args = args;
      this.function = function;
      if (empty(this.args))
        this.args = null;
    }

    public FunctionCall(Object function, List args) {
      this(function, toObjectArray(args));
    }

    public String toString() {
      return function + "(" + joinWithComma(allToString(args)) + ")";
    }

    public String toStringWithOptionalParens() {
      return empty(args) ? str(function) : toString();
    }

    public boolean equals(Object o) {
      return o instanceof FunctionCall && eq(function, ((FunctionCall) o).function) && objectArraysEqual(args, ((FunctionCall) o).args);
    }

    public int hashCode() {
      return hashAboutObjects(function, asList(args));
    }

    public List args() {
      return asList(args);
    }

    public Object transformUsing(IF1 f) {
      return new FunctionCall(f.get(function), mapObjectArray(f, args));
    }
  }

  static public class ScoredSearcher_stable<A> {

    public int maxResults = 1000;

    public boolean returnAll = false;

    public List<String> preparedTerms;

    public MultiMap<Double, A> byScore = descTreeMultiMap();

    public ScoredSearcher_stable() {
    }

    public ScoredSearcher_stable(String query, Object... __) {
      maxResults = optPar("maxResults", __, maxResults);
      setQuery(query);
    }

    public void setQuery(String query) {
      preparedTerms = scoredSearch_prepare(query);
    }

    public void put(A object, String s) {
      putScored(object, score(s));
    }

    public void putScored(A object, double score) {
      if (score != 0)
        byScore.add(score, object);
    }

    public void put(A object, Collection<String> fields) {
      add(object, scoreFields(fields));
    }

    public void putWithWeights(A object, Collection<Pair<String, Double>> fields) {
      scoredSearch_scoreWeighted2(fields, preparedTerms);
    }

    public int scoreFields(Collection<String> fields) {
      return scoredSearch_score(fields, preparedTerms);
    }

    public int score(String text) {
      return returnAll ? 1 : scoredSearch_score(text, preparedTerms);
    }

    public void add(A object) {
      put(object, str(object));
    }

    public void add(A object, Collection<String> fields) {
      put(object, fields);
    }

    public void put(A object, double score) {
      add(object, score);
    }

    public void add(A object, double score) {
      putScored(object, score);
    }

    public List<A> get() {
      return pairsB(takeFirst(maxResults, multiMapPairIterator(byScore)));
    }

    public List<A> get_transformListWithinScore(IF1<List<A>, List<A>> f) {
      return pairsB(takeFirst(maxResults, multiMapPairIterator_transformValueList(byScore, f)));
    }

    public List<Scored<A>> withScores() {
      return map(takeFirst(maxResults, multiMapPairIterator(byScore)), p -> new Scored(p.b, p.a));
    }

    public A best() {
      return firstValue(byScore);
    }
  }

  static public interface Transformable {

    public Object transformUsing(IF1 f);
  }

  static public class Scored<A> extends Var<A> {

    public float score;

    public Scored() {
    }

    public Scored(A a, float score) {
      super(a);
      this.score = score;
    }

    public Scored(A a, double score) {
      super(a);
      this.score = (float) score;
    }

    public float score() {
      return score;
    }

    public String toString() {
      return toIntPercent(score) + "%: " + str(get());
    }
  }

  static public float[] newFloatArray(int n) {
    return new float[n];
  }

  static public long nanoTime() {
    return System.nanoTime();
  }

  static public <A> List<A> reversed(Iterable<A> l) {
    return reversedList(l);
  }

  static public <A> List<A> reversed(A[] l) {
    return reversedList(asList(l));
  }

  static public String reversed(String s) {
    return reversedString(s);
  }

  static public <A> AutoCloseable tempAdd(Collection<A> l, A a) {
    if (l == null || l.contains(a))
      return null;
    l.add(a);
    return new AutoCloseable() {

      public String toString() {
        return "l.remove(a);";
      }

      public void close() throws Exception {
        l.remove(a);
      }
    };
  }

  static public String concatStrings(Object... l) {
    return join("", l);
  }

  static public String concatStrings(Iterable l) {
    return join("", l);
  }

  static public BigInteger plus(BigInteger a, BigInteger b) {
    return a.add(b);
  }

  static public BigInteger plus(BigInteger a, long b) {
    return a.add(bigint(b));
  }

  static public long plus(long a, long b) {
    return a + b;
  }

  static public int plus(int a, int b) {
    return a + b;
  }

  static public float plus(float a, float b) {
    return a + b;
  }

  static public double plus(double a, double b) {
    return a + b;
  }

  static public <A> List<A> minus(Collection<A> a, Object... b) {
    Set set = asSet(b);
    List l = new ArrayList();
    for (Object s : unnull(a)) if (!set.contains(s))
      l.add(s);
    return l;
  }

  static public BigInteger minus(BigInteger a, BigInteger b) {
    return a.subtract(b);
  }

  static public Complex minus(Complex c) {
    return c == null ? null : complex(-c.re(), -c.im());
  }

  static public int minus(int a, int b) {
    return a - b;
  }

  static public double minus(double a, double b) {
    return a - b;
  }

  static public Pt neg(Pt p) {
    return p == null ? null : new Pt(-p.x, -p.y);
  }

  static public int neg(int i) {
    return -i;
  }

  static public boolean lessThan(int a, int b) {
    return a < b;
  }

  static public boolean lessThan(double a, double b) {
    return a < b;
  }

  static public boolean greaterThan(Object a, Object b) {
    return cmp(a, b) > 0;
  }

  static public boolean greaterThan(int a, int b) {
    return a > b;
  }

  static public boolean greaterThan(double a, double b) {
    return a > b;
  }

  static public BufferedImage newImage(int w, int h) {
    return whiteImage(w, h);
  }

  static public BufferedImage newImage(int w, Color color) {
    return newImage(w, w, color);
  }

  static public BufferedImage newImage(int w, int h, Color color) {
    return bufferedImage(w, h, color);
  }

  static public BufferedImage newImage(int size) {
    return whiteImage(size);
  }

  static public BufferedImage newImage(Pt size) {
    return whiteImage(size.x, size.y);
  }

  static public BufferedImage newImage(WidthAndHeight size) {
    return whiteImage(size.w(), size.h());
  }

  static public BufferedImage newImage(Dimension size) {
    return whiteImage(size.width, size.height);
  }

  static public Rect randomRect(Rect outer) {
    var w = random_incl(outer.w);
    var h = random_incl(outer.h);
    return randomRect(w, h, outer);
  }

  static public Rect randomRect(int w, int h, Rect outer) {
    return translateRect(outer.x, outer.y, randomRect(outer.w, outer.h, 0, w, h));
  }

  static public Rect randomRect(Rect outer, int w, int h) {
    return randomRect(w, h, outer);
  }

  static public Rect randomRect(int w, int h, int rw, int rh) {
    return randomRect(w, h, 0, rw, rh);
  }

  static public Rect randomRect(int w, int h, int border, int rw, int rh) {
    if (rw > w - border * 2 || rh > h - border * 2)
      return null;
    int ww = random(border, w - border - rw);
    int hh = random(border, h - border - rh);
    return new Rect(ww, hh, rw, rh);
  }

  static public Rect randomRect(int w, int h) {
    int rw = random(w);
    int rh = random(h);
    return randomRect(w, h, 0, rw, rh);
  }

  static public Rect randomRect(RGBImage img, int rw, int rh) {
    return randomRect(img.w(), img.h(), 0, rw, rh);
  }

  static public Rect randomRect(RGBImage img) {
    return randomRect(img.w(), img.h());
  }

  static public Rect randomRect() {
    return randomRect(currentImage().getWidth(), currentImage().getHeight());
  }

  static public Rect randomRect(BufferedImage img, int rw, int rh) {
    return randomRect(img.getWidth(), img.getHeight(), 0, rw, rh);
  }

  static public long longPlus(long a, long b) {
    return a + b;
  }

  static public int intSum(Collection c, String field) {
    int sum = 0;
    for (Object o : unnull(c)) sum += toInt(getOpt(o, field));
    return sum;
  }

  static public int intSum(Iterable<Integer> l) {
    int sum = 0;
    for (Integer i : unnull(l)) if (i != null)
      sum += i;
    return sum;
  }

  static public int intSum(int... l) {
    int sum = 0;
    for (int i : unnull(l)) sum += i;
    return sum;
  }

  static public List repF(int n, Object f, Object... args) {
    List l = emptyList(n);
    for (int i = 0; i < n; i++) l.add(callF(f, args));
    return l;
  }

  static public List repF(Object f, int n) {
    return repF(n, f);
  }

  static public <A> List<A> repF(int n, IF0<A> f) {
    List<A> l = emptyList(n);
    for (int i = 0; i < n; i++) l.add(f.get());
    return l;
  }

  static public <A> List<A> repF(IF0<A> f, int n) {
    return repF(n, f);
  }

  static public IterableIterator<Integer> iota(final int n) {
    return new IterableIterator<Integer>() {

      public int i = 0;

      public boolean hasNext() {
        return i < n;
      }

      public Integer next() {
        return ++i;
      }
    };
  }

  static public <A, C extends Collection<A>> C assertContains(C c, A y) {
    return assertContains(null, c, y);
  }

  static public <A, C extends Collection<A>> C assertContains(String msg, C c, A y) {
    if (!contains(c, y))
      throw fail((msg != null ? msg + ": " : "") + y + " not contained in " + c);
    return c;
  }

  static public String assertContains(String a, String b) {
    if (!contains(a, b))
      throw fail(quote(b) + " not contained in " + quote(a));
    return a;
  }

  static public void assertNotEquals(String msg, Object a, Object b) {
    if (eq(a, b))
      throw fail(msg);
  }

  static public void assertNotEquals(Object a, Object b) {
    if (eq(a, b))
      throw fail(str(a));
  }

  static public Object preciseGetOrCallMethod(Object object, String name) {
    if (object == null)
      return null;
    if (canCallWithVarargs(object, name))
      return call(object, name);
    return _get(object, name);
  }

  static public <A> A set(A o, String field, Object value) {
    if (o == null)
      return null;
    if (o instanceof Class)
      set((Class) o, field, value);
    else
      try {
        Field f = set_findField(o.getClass(), field);
        makeAccessible(f);
        smartSet(f, o, value);
      } catch (Exception e) {
        throw new RuntimeException(e);
      }
    return o;
  }

  static public void set(Class c, String field, Object value) {
    if (c == null)
      return;
    try {
      Field f = set_findStaticField(c, field);
      makeAccessible(f);
      smartSet(f, null, value);
    } catch (Exception e) {
      throw new RuntimeException(e);
    }
  }

  static public Field set_findStaticField(Class<?> c, String field) {
    Class _c = c;
    do {
      for (Field f : _c.getDeclaredFields()) if (f.getName().equals(field) && (f.getModifiers() & java.lang.reflect.Modifier.STATIC) != 0)
        return f;
      _c = _c.getSuperclass();
    } while (_c != null);
    throw new RuntimeException("Static field '" + field + "' not found in " + c.getName());
  }

  static public Field set_findField(Class<?> c, String field) {
    Class _c = c;
    do {
      for (Field f : _c.getDeclaredFields()) if (f.getName().equals(field))
        return f;
      _c = _c.getSuperclass();
    } while (_c != null);
    throw new RuntimeException("Field '" + field + "' not found in " + c.getName());
  }

  static public void set(BitSet bs, int idx) {
    {
      if (bs != null)
        bs.set(idx);
    }
  }

  static public <A> A newObject(Class<A> c, Object... args) {
    return (A) nuObject(c, args);
  }

  static public Object newObject(String className, Object... args) {
    return nuObject(className, args);
  }

  static public Class<?> getClass(String name) {
    return _getClass(name);
  }

  static public Class getClass(Object o) {
    return _getClass(o);
  }

  static public Class getClass(Object realm, String name) {
    return _getClass(realm, name);
  }

  static public boolean classIsExportedTo(Class c, java.lang.Module destModule) {
    if (c == null || destModule == null)
      return false;
    java.lang.Module srcModule = c.getModule();
    String packageName = c.getPackageName();
    return srcModule.isExported(packageName, destModule);
  }

  static public boolean isAbstract(Class c) {
    return (c.getModifiers() & Modifier.ABSTRACT) != 0;
  }

  static public boolean isAbstract(Method m) {
    return (m.getModifiers() & Modifier.ABSTRACT) != 0;
  }

  static public boolean reflection_isForbiddenMethod(Method m) {
    return m.getDeclaringClass() == Object.class && eqOneOf(m.getName(), "finalize", "clone", "registerNatives");
  }

  static public <A, B> void multiMapPut(Map<A, List<B>> map, A a, B b) {
    List<B> l = map.get(a);
    if (l == null)
      map.put(a, l = new ArrayList());
    l.add(b);
  }

  static public <A, B> void multiMapPut(MultiMap<A, B> mm, A key, B value) {
    if (mm != null && key != null && value != null)
      mm.put(key, value);
  }

  static public Field makeAccessible(Field f) {
    try {
      f.setAccessible(true);
    } catch (Throwable e) {
      vmBus_send("makeAccessible_error", e, f);
    }
    return f;
  }

  static public Method makeAccessible(Method m) {
    try {
      m.setAccessible(true);
    } catch (Throwable e) {
      vmBus_send("makeAccessible_error", e, m);
    }
    return m;
  }

  static public Constructor makeAccessible(Constructor c) {
    try {
      c.setAccessible(true);
    } catch (Throwable e) {
      vmBus_send("makeAccessible_error", e, c);
    }
    return c;
  }

  static public Set<Class> allInterfacesImplementedBy(Object o) {
    return allInterfacesImplementedBy(_getClass(o));
  }

  static public Set<Class> allInterfacesImplementedBy(Class c) {
    if (c == null)
      return null;
    HashSet<Class> set = new HashSet();
    allInterfacesImplementedBy_find(c, set);
    return set;
  }

  static public void allInterfacesImplementedBy_find(Class c, Set<Class> set) {
    if (c.isInterface() && !set.add(c))
      return;
    do {
      for (Class intf : c.getInterfaces()) allInterfacesImplementedBy_find(intf, set);
    } while ((c = c.getSuperclass()) != null);
  }

  static public Method findMethod(Object o, String method, Object... args) {
    return findMethod_cached(o, method, args);
  }

  static public boolean findMethod_checkArgs(Method m, Object[] args, boolean debug) {
    Class<?>[] types = m.getParameterTypes();
    if (types.length != args.length) {
      if (debug)
        System.out.println("Bad parameter length: " + args.length + " vs " + types.length);
      return false;
    }
    for (int i = 0; i < types.length; i++) if (!(args[i] == null || isInstanceX(types[i], args[i]))) {
      if (debug)
        System.out.println("Bad parameter " + i + ": " + args[i] + " vs " + types[i]);
      return false;
    }
    return true;
  }

  static public boolean call_checkArgs(Method m, Object[] args, boolean debug) {
    Class<?>[] types = m.getParameterTypes();
    if (types.length != l(args)) {
      if (debug)
        print("Bad parameter length: " + args.length + " vs " + types.length);
      return false;
    }
    for (int i = 0; i < types.length; i++) {
      Object arg = args[i];
      if (!(arg == null ? !types[i].isPrimitive() : isInstanceX(types[i], arg))) {
        if (debug)
          print("Bad parameter " + i + ": " + arg + " vs " + types[i]);
        return false;
      }
    }
    return true;
  }

  static public Method findStaticMethod(Class c, String method, Object... args) {
    Class _c = c;
    while (c != null) {
      for (Method m : c.getDeclaredMethods()) {
        if (!m.getName().equals(method))
          continue;
        if ((m.getModifiers() & Modifier.STATIC) == 0 || !findStaticMethod_checkArgs(m, args))
          continue;
        return m;
      }
      c = c.getSuperclass();
    }
    return null;
  }

  static public boolean findStaticMethod_checkArgs(Method m, Object[] args) {
    Class<?>[] types = m.getParameterTypes();
    if (types.length != args.length)
      return false;
    for (int i = 0; i < types.length; i++) if (!(args[i] == null || isInstanceX(types[i], args[i])))
      return false;
    return true;
  }

  static public int _hashCode(Object a) {
    return a == null ? 0 : a.hashCode();
  }

  static public <A, B> boolean containsKey(Map<A, B> map, A key) {
    return map != null && map.containsKey(key);
  }

  static public <A, B> B mapGet(Map<A, B> map, A a) {
    return map == null || a == null ? null : map.get(a);
  }

  static public <A, B> B mapGet(A a, Map<A, B> map) {
    return map == null || a == null ? null : map.get(a);
  }

  static public <A, B> Map<A, B> putOrCreateSyncMap(Map<A, B> map, A key, B value) {
    if (map == null)
      map = syncHashMap();
    map.put(key, value);
    return map;
  }

  static public <A, B> AutoCloseable tempPut(Map<A, B> map, A key, B value) {
    if (map != null) {
      boolean wasContained = map.containsKey(key);
      B old = map.put(key, value);
      return () -> {
        if (wasContained)
          map.put(key, old);
        else
          map.remove(key);
      };
    }
    return null;
  }

  static public AutoCloseable tempSet(Object o, final String field, Object value) {
    return tempSetField(o, field, value);
  }

  static public <A> void remove(List<A> l, int i) {
    if (l != null && i >= 0 && i < l(l))
      l.remove(i);
  }

  static public <A> void remove(Collection<A> l, A a) {
    if (l != null)
      l.remove(a);
  }

  static public <A, B> B remove(Map<A, B> map, Object a) {
    return map == null ? null : map.remove(a);
  }

  static public void remove(BitSet bs, int i) {
    bs.clear(i);
  }

  static public <A extends Iterable> A pnl(A l) {
    return pnl("", l);
  }

  static public <A extends Iterable> A pnl(String prefix, A l) {
    printNumberedLines(prefix, l);
    return l;
  }

  static public <A> A[] pnl(A[] l) {
    return pnl("", l);
  }

  static public <A> A[] pnl(String prefix, A[] l) {
    printNumberedLines(prefix, l);
    return l;
  }

  static public <A extends Map> A pnl(A map) {
    printNumberedLines(map);
    return map;
  }

  static public <A extends Map> A pnl(String prefix, A map) {
    printNumberedLines(prefix, map);
    return map;
  }

  static public String pnl(String s) {
    printNumberedLines(lines(s));
    return s;
  }

  static public <A> MultiSet<A> pnl(MultiSet<A> ms) {
    pnl(ms == null ? null : ms.asMap());
    return ms;
  }

  static public <A, B> MultiMap<A, B> pnl(MultiMap<A, B> mm) {
    pnl(mm == null ? null : mm.asMap());
    return mm;
  }

  static public Map syncHashMap() {
    return synchroHashMap();
  }

  static public Object metaGet(IMeta o, Object key) {
    return metaMapGet(o, key);
  }

  static public Object metaGet(Object o, Object key) {
    return metaMapGet(o, key);
  }

  static public Object metaGet(String key, IMeta o) {
    return metaMapGet(o, key);
  }

  static public Object metaGet(String key, Object o) {
    return metaMapGet(o, key);
  }

  static public Object metaMapGet(IMeta o, Object key) {
    return o == null ? null : o.metaGet(key);
  }

  static public Object metaMapGet(Object o, Object key) {
    return metaMapGet(toIMeta(o), key);
  }

  static public void metaPut(IMeta o, Object key, Object value) {
    metaMapPut(o, key, value);
  }

  static public void metaPut(Object o, Object key, Object value) {
    metaMapPut(o, key, value);
  }

  static public void metaMapPut(IMeta o, Object key, Object value) {
    {
      if (o != null)
        o.metaPut(key, value);
    }
  }

  static public void metaMapPut(Object o, Object key, Object value) {
    var meta = initIMeta(o);
    {
      if (meta != null)
        meta.metaPut(key, value);
    }
  }

  static public Map convertObjectMetaToMap(IMeta o) {
    return convertObjectMetaToMap(o, () -> makeObjectMetaMap());
  }

  static public Map convertObjectMetaToMap(IMeta o, IF0<Map> createEmptyMap) {
    if (o == null)
      return null;
    Object meta = o._getMeta();
    if (meta instanceof Map)
      return ((Map) meta);
    var mutex = tempMetaMutex(o);
    try {
      var actualMutex = mutex.get();
      synchronized (actualMutex) {
        meta = o._getMeta();
        if (meta instanceof Map)
          return ((Map) meta);
        Map map = createEmptyMap.get();
        if (meta != null)
          map.put("previousMeta", meta);
        o._setMeta(map);
        return map;
      }
    } finally {
      _close(mutex);
    }
  }

  static public <A, B> void syncMapPutOrRemove(Map<A, B> map, A key, B value) {
    syncMapPut2(map, key, value);
  }

  static public void lock(Lock lock) {
    try {
      ping();
      if (lock == null)
        return;
      try {
        vmBus_send("locking", lock, "thread", currentThread());
        lock.lockInterruptibly();
        vmBus_send("locked", lock, "thread", currentThread());
      } catch (InterruptedException e) {
        Object reason = vm_threadInterruptionReasonsMap().get(currentThread());
        print("Locking interrupted! Reason: " + strOr(reason, "Unknown"));
        printStackTrace(e);
        rethrow(e);
      }
    } catch (Exception __e) {
      throw rethrow(__e);
    }
  }

  static public void lock(Lock lock, String msg) {
    print("Locking: " + msg);
    lock(lock);
  }

  static public void lock(Lock lock, String msg, long timeout) {
    print("Locking: " + msg);
    lockOrFail(lock, timeout);
  }

  static public ReentrantLock lock() {
    return fairLock();
  }

  static public void unlock(Lock lock, String msg) {
    if (lock == null)
      return;
    lock.unlock();
    vmBus_send("unlocked", lock, "thread", currentThread());
    print("Unlocked: " + msg);
  }

  static public void unlock(Lock lock) {
    if (lock == null)
      return;
    lock.unlock();
    vmBus_send("unlocked", lock, "thread", currentThread());
  }

  static public G22Utils g22utils(Concepts cc) {
    return (G22Utils) cc.miscMapGet(G22Utils.class);
  }

  static public <A> HashSet<A> litset(A... items) {
    return lithashset(items);
  }

  static public <A> Set<A> createOrAddToSyncLinkedHashSet(Set<A> set, A a) {
    if (set == null)
      set = syncLinkedHashSet();
    set.add(a);
    return set;
  }

  static public <A> A pcallF_typed(F0<A> f) {
    try {
      return f == null ? null : f.get();
    } catch (Throwable __e) {
      printStackTrace(__e);
    }
    return null;
  }

  static public <A, B> B pcallF_typed(F1<A, B> f, A a) {
    try {
      return f == null ? null : f.get(a);
    } catch (Throwable __e) {
      printStackTrace(__e);
    }
    return null;
  }

  static public <A> void pcallF_typed(VF1<A> f, A a) {
    try {
      {
        if (f != null)
          f.get(a);
      }
    } catch (Throwable __e) {
      printStackTrace(__e);
    }
  }

  static public <A> void pcallF_typed(IVF1<A> f, A a) {
    try {
      {
        if (f != null)
          f.get(a);
      }
    } catch (Throwable __e) {
      printStackTrace(__e);
    }
  }

  static public <A, B> void pcallF_typed(IVF2<A, B> f, A a, B b) {
    try {
      {
        if (f != null)
          f.get(a, b);
      }
    } catch (Throwable __e) {
      printStackTrace(__e);
    }
  }

  static public Object pcallF_typed(Runnable r) {
    try {
      {
        if (r != null)
          r.run();
      }
    } catch (Throwable __e) {
      printStackTrace(__e);
    }
    return null;
  }

  static public <A> A pcallF_typed(IF0<A> f) {
    try {
      return f == null ? null : f.get();
    } catch (Throwable __e) {
      printStackTrace(__e);
    }
    return null;
  }

  static public <A, B> B pcallF_typed(IF1<A, B> f, A a) {
    try {
      return f == null ? null : f.get(a);
    } catch (Throwable __e) {
      printStackTrace(__e);
    }
    return null;
  }

  static public String shortClassName_dropNumberPrefix(Object o) {
    return dropNumberPrefix(shortClassName(o));
  }

  static public int boostHashCombine(int a, int b) {
    return a ^ (b + 0x9e3779b9 + (a << 6) + (a >>> 2));
  }

  static public <A> A last(List<A> l) {
    return empty(l) ? null : l.get(l.size() - 1);
  }

  static public char last(String s) {
    return empty(s) ? '#' : s.charAt(l(s) - 1);
  }

  static public byte last(byte[] a) {
    return l(a) != 0 ? a[l(a) - 1] : 0;
  }

  static public int last(int[] a) {
    return l(a) != 0 ? a[l(a) - 1] : 0;
  }

  static public double last(double[] a) {
    return l(a) != 0 ? a[l(a) - 1] : 0;
  }

  static public <A> A last(A[] a) {
    return l(a) != 0 ? a[l(a) - 1] : null;
  }

  static public <A> A last(Iterator<A> it) {
    A a = null;
    while (it.hasNext()) {
      ping();
      a = it.next();
    }
    return a;
  }

  static public <A> A last(Collection<A> l) {
    if (l == null)
      return null;
    if (l instanceof List)
      return (A) last((List) l);
    if (l instanceof SortedSet)
      return (A) last((SortedSet) l);
    Iterator<A> it = iterator(l);
    A a = null;
    while (it.hasNext()) {
      ping();
      a = it.next();
    }
    return a;
  }

  static public <A> A last(SortedSet<A> l) {
    return l == null ? null : l.last();
  }

  static public <A> A last(ReverseChain<A> l) {
    return l == null ? null : l.element;
  }

  static public <A> A last(CompactLinkedHashSet<A> set) {
    return set == null ? null : set.last();
  }

  static public <A> void replaceLast(List<A> l, A a) {
    replaceLastElement(l, a);
  }

  static public <A> A[] toTypedArray(Class<A> type, Iterable<A> c) {
    return toArray(c, type);
  }

  static public <A> String pnlToLines(String prefix, Iterable<A> l) {
    return pnlToString(prefix, l);
  }

  static public <A> String pnlToLines(Iterable<A> l) {
    return pnlToString(l);
  }

  static public <A> String pnlToLines(A[] l) {
    return pnlToString(l);
  }

  static public <A, B> String pnlToLines(Map<A, B> map) {
    return pnlToString(map);
  }

  static public <A, B> String pnlToLines(MultiMap<A, B> map) {
    return pnlToString(map);
  }

  static public String formatRecordVars(String recordName, Object... params) {
    return renderRecordVars(recordName, params);
  }

  static public boolean setText_opt = true;

  static public <A extends JTextComponent> A setText(A c, Object text) {
    setText((JComponent) c, text);
    return c;
  }

  static public <A extends JComboBox> A setText(final A c, Object text) {
    final String s = strUnnull(text);
    {
      swing(() -> {
        c.getEditor().setItem(s);
      });
    }
    return c;
  }

  static public void setText(JLabel c, Object text) {
    setText((JComponent) c, text);
  }

  static public JButton setText(JButton c, Object text) {
    setText((JComponent) c, jlabel_textAsHTML_center_ifNeeded(strUnnull(text)));
    return c;
  }

  static public <A extends JComponent> A setText(final A c, Object text) {
    if (c == null)
      return null;
    final String s = strUnnull(text);
    {
      swing(() -> {
        if (!setText_opt || neq(callOpt(c, "getText"), s))
          call(c, "setText", s);
      });
    }
    return c;
  }

  static public RuntimeException rethrowAndAppendToMessage(Throwable t, String msg) {
    String haveMsg = t.getMessage();
    if (empty(msg) || endsWith(haveMsg, " " + msg))
      throw rethrow(t);
    throw new RuntimeException(joinWithSpace(t.getMessage(), msg), t);
  }

  static public String squareBracketed(String s) {
    return "[" + s + "]";
  }

  static public <A, B> AutoCloseable tempRestoreMap(Map<A, B> map) {
    if (map == null)
      return null;
    var cloned = cloneMap(map);
    return () -> copyMap(cloned, map);
  }

  static public boolean is(String a, String b) {
    return false;
  }

  static public String assertIdentifier(String s) {
    return assertIsIdentifier(s);
  }

  static public String assertIdentifier(String msg, String s) {
    return assertIsIdentifier(msg, s);
  }

  static public void printVars(Object... params) {
    printVars_str(params);
  }

  static public void scaffoldCalled(Object obj, Object function, Object... args) {
    printShortenedFunctionCall(200, (obj == null ? "" : shorten(20, str(obj)) + " :: ") + function, args);
  }

  static public <A> A printIndentedStructIf(boolean b, A a) {
    if (b)
      printIndentedStruct(a);
    return a;
  }

  static public <A> A printIndentedStructIf(boolean b, String s, A a) {
    if (b)
      printIndentedStruct(s, a);
    return a;
  }

  static public boolean scaffoldingEnabled(Object o) {
    return metaGet(o, "scaffolding") != null;
  }

  static public boolean startsWithDigit(String s) {
    return nempty(s) && isDigit(s.charAt(0));
  }

  static public String unquote(String s) {
    if (s == null)
      return null;
    if (startsWith(s, '[')) {
      int i = 1;
      while (i < s.length() && s.charAt(i) == '=') ++i;
      if (i < s.length() && s.charAt(i) == '[') {
        String m = s.substring(1, i);
        if (s.endsWith("]" + m + "]"))
          return s.substring(i + 1, s.length() - i - 1);
      }
    }
    if (s.length() > 1) {
      char c = s.charAt(0);
      if (c == '\"' || c == '\'') {
        int l = endsWith(s, c) ? s.length() - 1 : s.length();
        StringBuilder sb = new StringBuilder(l - 1);
        for (int i = 1; i < l; i++) {
          char ch = s.charAt(i);
          if (ch == '\\') {
            char nextChar = (i == l - 1) ? '\\' : s.charAt(i + 1);
            if (nextChar >= '0' && nextChar <= '7') {
              String code = "" + nextChar;
              i++;
              if ((i < l - 1) && s.charAt(i + 1) >= '0' && s.charAt(i + 1) <= '7') {
                code += s.charAt(i + 1);
                i++;
                if ((i < l - 1) && s.charAt(i + 1) >= '0' && s.charAt(i + 1) <= '7') {
                  code += s.charAt(i + 1);
                  i++;
                }
              }
              sb.append((char) Integer.parseInt(code, 8));
              continue;
            }
            switch(nextChar) {
              case '\"':
                ch = '\"';
                break;
              case '\\':
                ch = '\\';
                break;
              case 'b':
                ch = '\b';
                break;
              case 'f':
                ch = '\f';
                break;
              case 'n':
                ch = '\n';
                break;
              case 'r':
                ch = '\r';
                break;
              case 't':
                ch = '\t';
                break;
              case '\'':
                ch = '\'';
                break;
              case 'u':
                if (i >= l - 5) {
                  ch = 'u';
                  break;
                }
                int code = Integer.parseInt("" + s.charAt(i + 2) + s.charAt(i + 3) + s.charAt(i + 4) + s.charAt(i + 5), 16);
                sb.append(Character.toChars(code));
                i += 5;
                continue;
              default:
                ch = nextChar;
            }
            i++;
          }
          sb.append(ch);
        }
        return sb.toString();
      }
    }
    return s;
  }

  static public boolean swic(String a, String b) {
    return startsWithIgnoreCase(a, b);
  }

  static public boolean swic(String a, String b, Matches m) {
    if (!swic(a, b))
      return false;
    m.m = new String[] { substring(a, l(b)) };
    return true;
  }

  static public int parseHexInt(String s) {
    return hexToInt(s);
  }

  static public String[] dropFirst(int n, String[] a) {
    return drop(n, a);
  }

  static public String[] dropFirst(String[] a) {
    return drop(1, a);
  }

  static public Object[] dropFirst(Object[] a) {
    return drop(1, a);
  }

  static public <A> List<A> dropFirst(List<A> l) {
    return dropFirst(1, l);
  }

  static public <A> List<A> dropFirst(int n, Iterable<A> i) {
    return dropFirst(n, toList(i));
  }

  static public <A> List<A> dropFirst(Iterable<A> i) {
    return dropFirst(toList(i));
  }

  static public <A> List<A> dropFirst(int n, List<A> l) {
    return n <= 0 ? l : new ArrayList(l.subList(Math.min(n, l.size()), l.size()));
  }

  static public <A> List<A> dropFirst(List<A> l, int n) {
    return dropFirst(n, l);
  }

  static public String dropFirst(int n, String s) {
    return substring(s, n);
  }

  static public String dropFirst(String s, int n) {
    return substring(s, n);
  }

  static public String dropFirst(String s) {
    return substring(s, 1);
  }

  static public <A> Chain<A> dropFirst(Chain<A> c) {
    return c == null ? null : c.next;
  }

  static public int intFromBinary(String s) {
    return Integer.parseInt(s, 2);
  }

  static public float parseFloat(String s) {
    return Float.parseFloat(s);
  }

  static public boolean hasMethodNamed(Object obj, String method) {
    if (obj == null)
      return false;
    if (obj instanceof Class)
      return hasMethodNamed((Class) obj, method);
    return hasMethodNamed(obj.getClass(), method);
  }

  static public boolean hasMethodNamed(Class c, String method) {
    if (c == null)
      return false;
    return getMethodCache(c).cache.containsKey(method);
  }

  static public boolean isInterface(Class c) {
    return c != null && c.isInterface();
  }

  static public boolean isStaticField(Field f) {
    return (f.getModifiers() & Modifier.STATIC) != 0;
  }

  static public List<Constructor> constructorsWithNumberOfArguments(Class c, int n) {
    return filter(getDeclaredConstructors_cached(c), con -> l(con.getParameterTypes()) == n);
  }

  static public Object[] toArray(Collection c) {
    return toObjectArray(c);
  }

  static public <A> A[] toArray(Class<A> type, Iterable<A> c) {
    return toArray(c, type);
  }

  static public <A> A[] toArray(Class<A> type, Collection<A> c) {
    return toArray(c, type);
  }

  static public <A> A[] toArray(Collection<A> c, Class<A> type) {
    A[] a = arrayOfType(l(c), type);
    if (a.length == 0)
      return a;
    asList(c).toArray(a);
    return a;
  }

  static public <A> A[] toArray(Iterable<A> c, Class<A> type) {
    var c2 = asList(c);
    A[] a = arrayOfType(l(c2), type);
    if (a.length == 0)
      return a;
    c2.toArray(a);
    return a;
  }

  static public <A> A[] toArray(A[] array, Collection c) {
    if (array == null || c == null)
      return null;
    asList(c).toArray(array);
    return array;
  }

  static public <A> A[] toArrayOrNull(Class<A> type, Collection<A> c) {
    if (empty(c))
      return null;
    return toArray(type, c);
  }

  static public Map<String, Class> classForName_cache = synchroHashMap();

  static public Class classForName(String name) {
    return classForName(name, null);
  }

  static public Class classForName(String name, Object classFinder) {
    if (classForName_cache == null || classFinder != null)
      return classForName_uncached(name, classFinder);
    Class c = classForName_cache.get(name);
    if (c == null)
      classForName_cache.put(name, c = classForName_uncached(name, null));
    return c;
  }

  static public Class classForName_uncached(String name, Object classFinder) {
    try {
      if (classFinder != null)
        return (Class) callF(classFinder, name);
      return Class.forName(name);
    } catch (Exception __e) {
      throw rethrow(__e);
    }
  }

  static public <A, B> Collection<B> values(Map<A, B> map) {
    return map == null ? emptyList() : map.values();
  }

  static public Collection values(Object map) {
    return values((Map) map);
  }

  static public <A, B> Collection<B> values(MultiMap<A, B> mm) {
    return mm == null ? emptyList() : concatLists(values(mm.data));
  }

  static public <A, B> AutoCloseable tempMapPutAll(Map<A, B> map, Map<A, B> toAdd) {
    if (map != null && nempty(toAdd)) {
      List<Pair<A, B>> toRestore = new ArrayList();
      for (var __0 : _entrySet(toAdd)) {
        var key = __0.getKey();
        var value = __0.getValue();
        if (key != null && value != null) {
          B old = map.put(key, value);
          if (!eq(old, value))
            toRestore.add(pair(key, old));
        }
      }
      return () -> {
        for (var p : toRestore) mapPutOrRemove(map, p.a, p.b);
      };
    }
    return null;
  }

  static public <A, B> Map<A, B> mapWithSingleValue(Iterable<A> l, B b) {
    HashMap<A, B> map = new HashMap();
    if (l != null)
      for (A a : l) map.put(a, b);
    return map;
  }

  static public TreeSet mapToTreeSet(Object f, Iterable l) {
    TreeSet x = new TreeSet();
    if (l != null)
      for (Object o : l) x.add(callF(f, o));
    return x;
  }

  static public <A, B> TreeSet<B> mapToTreeSet(IF1<A, B> f, Iterable<A> l) {
    TreeSet<B> x = new TreeSet();
    if (l != null)
      for (var o : l) x.add(f.get(o));
    return x;
  }

  static public <A, B> TreeSet<B> mapToTreeSet(Iterable<A> l, IF1<A, B> f) {
    return mapToTreeSet(f, l);
  }

  static public boolean isAnonymousClass(Class c) {
    return isAnonymousClassName(className(c));
  }

  static public String shortClassName(Object o) {
    if (o == null)
      return null;
    Class c = o instanceof Class ? (Class) o : o.getClass();
    String name = c.getName();
    return shortenClassName(name);
  }

  static public boolean isAnonymousClassName(String s) {
    for (int i = 0; i < l(s); i++) if (s.charAt(i) == '$' && Character.isDigit(s.charAt(i + 1)))
      return true;
    return false;
  }

  static public String longestPrefixInTreeSet(String s, TreeSet<String> set) {
    return longestPrefixInNavigableSet(s, set);
  }

  static public String dropPrefix(String prefix, String s) {
    return s == null ? null : s.startsWith(prefix) ? s.substring(l(prefix)) : s;
  }

  static public Map<String, String> javaxClassShortcuts_cache;

  static public Map<String, String> javaxClassShortcuts() {
    if (javaxClassShortcuts_cache == null)
      javaxClassShortcuts_cache = javaxClassShortcuts_load();
    return javaxClassShortcuts_cache;
  }

  static public Map<String, String> javaxClassShortcuts_load() {
    return litmap("O", "Object", "S", "String", "L", "List", "Cl", "Collection");
  }

  static public <A> List<A> itemPlus(A a, Collection<A> l) {
    return itemPlusList(a, l);
  }

  static public List<String> standardImports_fullyImportedPackages() {
    return endingWith_dropSuffix(standardImports(), ".*");
  }

  static public BetterThreadLocal<PingSource> pingSource_tl_var = new BetterThreadLocal<PingSource>() {

    @Override
    public PingSource initialValue() {
      return ping_v3_pingSourceMaker().get();
    }
  };

  static public BetterThreadLocal<PingSource> pingSource_tl() {
    return pingSource_tl_var;
  }

  static public <A, B> LinkedHashMap<A, B> cloneLinkedHashMap(Map<A, B> map) {
    return map == null ? new LinkedHashMap() : new LinkedHashMap(map);
  }

  static public <A> A second(List<A> l) {
    return get(l, 1);
  }

  static public <A> A second(Iterable<A> l) {
    if (l == null)
      return null;
    Iterator<A> it = iterator(l);
    if (!it.hasNext())
      return null;
    it.next();
    return it.hasNext() ? it.next() : null;
  }

  static public <A> A second(A[] bla) {
    return bla == null || bla.length <= 1 ? null : bla[1];
  }

  static public <A, B> B second(Pair<A, B> p) {
    return p == null ? null : p.b;
  }

  static public <A, B, C> B second(T3<A, B, C> t) {
    return t == null ? null : t.b;
  }

  static public <A> A second(Producer<A> p) {
    if (p == null)
      return null;
    if (p.next() == null)
      return null;
    return p.next();
  }

  static public char second(String s) {
    return charAt(s, 1);
  }

  static public <A, B> B second(Either<A, B> e) {
    return e == null ? null : e.bOpt();
  }

  static public <A, B> Map<A, B> putAll(Map<A, B> a, Map<? extends A, ? extends B> b) {
    if (a != null && b != null)
      a.putAll(b);
    return a;
  }

  static public <A, B> MultiMap<A, B> putAll(MultiMap<A, B> a, Map<? extends A, ? extends B> b) {
    if (a != null)
      a.putAll((Map) b);
    return a;
  }

  static public <A, B> Map<A, B> putAll(Map<A, B> a, Object... b) {
    if (a != null)
      litmap_impl(a, b);
    return a;
  }

  static public <A, B> void put(Map<A, B> map, A a, B b) {
    if (map != null)
      map.put(a, b);
  }

  static public <A> void put(List<A> l, int i, A a) {
    if (l != null && i >= 0 && i < l(l))
      l.set(i, a);
  }

  static public <A> A getAndClear(IVar<A> v) {
    A a = v.get();
    v.set(null);
    return a;
  }

  static public <A, B> Set<A> keys(Map<A, B> map) {
    return map == null ? new HashSet() : map.keySet();
  }

  static public Set keys(Object map) {
    return keys((Map) map);
  }

  static public <A> Set<A> keys(MultiSet<A> ms) {
    return ms.keySet();
  }

  static public <A, B> Set<A> keys(IMultiMap<A, B> mm) {
    return mm.keySet();
  }

  static public <A, B> Set<A> keySet(Map<A, B> map) {
    return map == null ? new HashSet() : map.keySet();
  }

  static public Set keySet(Object map) {
    return keys((Map) map);
  }

  static public <A> Set<A> keySet(MultiSet<A> ms) {
    return ms.keySet();
  }

  static public <A, B> Set<A> keySet(MultiMap<A, B> mm) {
    return mm.keySet();
  }

  static public <A, B> int keysSize(MultiMap<A, B> mm) {
    return lKeys(mm);
  }

  static public <A> A reverseGet(List<A> l, int idx) {
    if (l == null || idx < 0)
      return null;
    int n = l(l);
    return idx < n ? l.get(n - 1 - idx) : null;
  }

  static public <A, B> Map<A, B> cloneMap(Map<A, B> map) {
    if (map == null)
      return new HashMap();
    synchronized (map) {
      return map instanceof TreeMap ? new TreeMap((TreeMap) map) : map instanceof LinkedHashMap ? new LinkedHashMap(map) : new HashMap(map);
    }
  }

  static public <A, B> List<B> cloneMap(Iterable<A> l, IF1<A, B> f) {
    List x = emptyList(l);
    if (l != null)
      for (A o : cloneList(l)) x.add(f.get(o));
    return x;
  }

  static public <A, B, C extends Collection<B>> List<B> allValues(Map<A, C> map) {
    List<B> out = new ArrayList();
    for (var l : values(map)) addAll(out, l);
    return out;
  }

  static public <A> List<A> concatLists(Iterable<A>... lists) {
    List<A> l = new ArrayList();
    if (lists != null)
      for (Iterable<A> list : lists) addAll(l, list);
    return l;
  }

  static public <A> List<A> concatLists(Collection<? extends Iterable<A>> lists) {
    List<A> l = new ArrayList();
    if (lists != null)
      for (Iterable<A> list : lists) addAll(l, list);
    return l;
  }

  static public <A> Iterator<A> iterator(Iterable<A> c) {
    return c == null ? emptyIterator() : c.iterator();
  }

  static public Method hashMap_findKey_method;

  static public <A, B> A hashMap_findKey(HashMap<A, B> map, Object key) {
    try {
      if (hashMap_findKey_method == null)
        hashMap_findKey_method = findMethodNamed(HashMap.class, "getNode");
      Map.Entry<A, B> entry = (Map.Entry) hashMap_findKey_method.invoke(map, hashMap_internalHash(key), key);
      return entry == null ? null : entry.getKey();
    } catch (Exception __e) {
      throw rethrow(__e);
    }
  }

  static public <A, B> void testFunctionValue(IF1<A, B> function, A in, B expected) {
    String what = print(renderFunctionCall(str(function), in));
    assertEqualsVerbose(what, expected, function.get(in));
  }

  static public String nTests(long n) {
    return n2(n, "test");
  }

  static public String nTests(Collection l) {
    return nTests(l(l));
  }

  static public Class run(String progID, String... args) {
    Class main = hotwire(progID);
    callMain(main, args);
    return main;
  }

  static public void clear(Collection c) {
    if (c != null)
      c.clear();
  }

  static public void clear(Map map) {
    if (map != null)
      map.clear();
  }

  static public String a(String noun) {
    if (eq(noun, ""))
      return "?";
    return ("aeiou".indexOf(noun.charAt(0)) >= 0 ? "an " : "a ") + noun;
  }

  static public String a(String contents, Object... params) {
    return hfulltag("a", contents, params);
  }

  static public String b(Object contents, Object... params) {
    return tag("b", contents, params);
  }

  static public int hashCodeFor(Object a) {
    return a == null ? 0 : a.hashCode();
  }

  static public String joinNemptiesWithColon(String... strings) {
    return joinNempties(": ", strings);
  }

  static public String joinNemptiesWithColon(Collection<String> strings) {
    return joinNempties(": ", strings);
  }

  static public String commaCombine(Object... l) {
    return joinNemptiesWithComma(flattenCollectionsAndArrays(ll(l)));
  }

  static public void assertSame(Object a, Object b) {
    assertSame("", a, b);
  }

  static public void assertSame(String msg, Object a, Object b) {
    if (a != b)
      throw fail(joinNemptiesWithColon(msg, a + " != " + b + " (" + identityHash(a) + "/" + identityHash(b) + ")"));
  }

  static public void assertSame(IF0<String> msg, Object a, Object b) {
    if (a != b)
      throw fail(joinNemptiesWithColon(msg.get(), a + " != " + b + " (" + identityHash(a) + "/" + identityHash(b) + ")"));
  }

  static public LineAndColumn tokenToLineAndColumn(ListAndIndex<String> ptr) {
    return ptr == null ? null : tokenToLineAndColumn(ptr.list(), ptr.idx());
  }

  static public LineAndColumn tokenToLineAndColumn(List<String> tok, int tokenIndex) {
    int line = 1, col = 1;
    tokenIndex = min(tokenIndex, l(tok));
    for (int i = 0; i < tokenIndex; i++) {
      String t = tok.get(i);
      int n = l(t);
      for (int j = 0; j < n; j++) if (t.charAt(j) == '\n') {
        ++line;
        col = 1;
      } else
        ++col;
    }
    return new LineAndColumn(line, col);
  }

  static public String or2(String a, String b) {
    return nempty(a) ? a : b;
  }

  static public String or2(String a, String b, String c) {
    return or2(or2(a, b), c);
  }

  static public List syncMap(Object f, Map map) {
    return syncMap(map, f);
  }

  static public List syncMap(Map map, Object f) {
    return map(cloneLinkedHashMap(map), f);
  }

  static public <A, B> Map<A, B> syncMap() {
    return synchroHashMap();
  }

  static public <A, B> Map<A, B> syncMap(Map map) {
    return synchronizedMap(map);
  }

  static volatile public int numberOfCores_value;

  static public int numberOfCores() {
    if (numberOfCores_value == 0)
      numberOfCores_value = Runtime.getRuntime().availableProcessors();
    return numberOfCores_value;
  }

  static public int random(int n) {
    return random(n, defaultRandomGenerator());
  }

  static public int random(int n, Random r) {
    return random(r, n);
  }

  static public int random(Random r, int n) {
    return n <= 0 ? 0 : getRandomizer(r).nextInt(n);
  }

  static public double random(double max) {
    return random() * max;
  }

  static public double random() {
    return defaultRandomGenerator().nextInt(100001) / 100000.0;
  }

  static public double random(double min, double max) {
    return min + random() * (max - min);
  }

  static public int random(int min, int max) {
    return min + random(max - min);
  }

  static public int random(int min, int max, Random r) {
    return random(r, min, max);
  }

  static public int random(Random r, int min, int max) {
    return min + random(r, max - min);
  }

  static public <A> A random(List<A> l) {
    return oneOf(l);
  }

  static public <A> A random(Collection<A> c) {
    if (c instanceof List)
      return random((List<A>) c);
    int i = random(l(c));
    return collectionGet(c, i);
  }

  static public int random(IntRange r) {
    return random(r.start, r.end);
  }

  static public <A, B> Pair<A, B> random(Map<A, B> map) {
    return entryToPair(random(entries(map)));
  }

  static public <A> A popFirst(List<A> l) {
    if (empty(l))
      return null;
    A a = first(l);
    l.remove(0);
    return a;
  }

  static public <A> A popFirst(Collection<A> l) {
    if (empty(l))
      return null;
    A a = first(l);
    l.remove(a);
    return a;
  }

  static public <A, B> Pair<A, B> popFirst(Map<A, B> map) {
    if (map == null)
      return null;
    var it = map.entrySet().iterator();
    if (!it.hasNext())
      return null;
    var p = mapEntryToPair(it.next());
    it.remove();
    return p;
  }

  static public <A> List<A> popFirst(int n, List<A> l) {
    List<A> part = cloneSubList(l, 0, n);
    removeSubList(l, 0, n);
    return part;
  }

  static public <A> AppendableChain<A> popFirst(AppendableChain<A> a) {
    return a == null ? null : a.popFirst();
  }

  static public <A> Chain<A> chainPlus(Chain<A> chain, A a) {
    return new Chain<A>(a, chain);
  }

  static public <A> Chain<A> chainPlus(Chain<A> chain, A... l) {
    for (A a : unnullForIteration(l)) chain = chainPlus(chain, a);
    return chain;
  }

  static public <A> ReverseChain<A> chainPlus(ReverseChain<A> chain, A a) {
    return new ReverseChain<A>(chain, a);
  }

  static public <A> ReverseChain<A> chainPlus(ReverseChain<A> chain, A... l) {
    for (A a : unnullForIteration(l)) chain = chainPlus(chain, a);
    return chain;
  }

  static public <A> AppendableChain<A> chainPlus(AppendableChain<A> chain, A a) {
    if (chain == null)
      return new AppendableChain<A>(a);
    chain.add(a);
    return chain;
  }

  static public <A> AppendableChain<A> chainPlus(AppendableChain<A> chain, A... l) {
    for (A a : unnullForIteration(l)) chain = chainPlus(chain, a);
    return chain;
  }

  static public String n2(long l) {
    return formatWithThousands(l);
  }

  static public String n2(AtomicLong l) {
    return n2(l.get());
  }

  static public String n2(Collection l) {
    return n2(l(l));
  }

  static public String n2(Map map) {
    return n2(l(map));
  }

  static public String n2(double l, String singular) {
    return empty(singular) ? str(l) : n2(l, singular, singular + "s");
  }

  static public String n2(double l, String singular, String plural) {
    if (fraction(l) == 0)
      return n2((long) l, singular, plural);
    else
      return l + " " + plural;
  }

  static public String n2(long l, String singular, String plural) {
    return n_fancy2(l, singular, plural);
  }

  static public String n2(long l, String singular) {
    return empty(singular) ? n2(l) : n_fancy2(l, singular, singular + "s");
  }

  static public String n2(Collection l, String singular) {
    return n2(l(l), singular);
  }

  static public String n2(Collection l, String singular, String plural) {
    return n_fancy2(l, singular, plural);
  }

  static public String n2(Map m, String singular, String plural) {
    return n_fancy2(m, singular, plural);
  }

  static public String n2(Map m, String singular) {
    return n2(l(m), singular);
  }

  static public String n2(long[] a, String singular) {
    return n2(l(a), singular);
  }

  static public String n2(Object[] a, String singular) {
    return n2(l(a), singular);
  }

  static public String n2(Object[] a, String singular, String plural) {
    return n_fancy2(a, singular, plural);
  }

  static public String n2(MultiSet ms, String singular) {
    return n2(ms, singular, singular + "s");
  }

  static public String n2(MultiSet ms, String singular, String plural) {
    return n_fancy2(ms, singular, plural);
  }

  static public String n2(IMultiMap mm, String singular) {
    return n2(mm, singular, singular + "s");
  }

  static public String n2(IMultiMap mm, String singular, String plural) {
    return n_fancy2(l(mm), singular, plural);
  }

  static public String roundBracket(String s) {
    return "(" + s + ")";
  }

  static public String roundBracket(Object s) {
    return roundBracket(str(s));
  }

  static public void syncNotifyAll(Object o) {
    if (o != null)
      synchronized (o) {
        o.notifyAll();
      }
  }

  static public ImageSurface pixelatedImageSurface() {
    var is = imageSurface();
    imageSurface_pixelated(is);
    return is;
  }

  static public ImageSurface pixelatedImageSurface(MakesBufferedImage img) {
    return pixelatedImageSurface(toBufferedImage(img));
  }

  static public ImageSurface pixelatedImageSurface(BufferedImage img) {
    var is = pixelatedImageSurface();
    is.setImage(img);
    return is;
  }

  static public File dbDir() {
    return programDir(dbProgramID());
  }

  static public BufferedImage toBufferedImage(Object o) {
    return toBufferedImageOpt(o);
  }

  static public <A> A assertEquals(Object x, A y) {
    return assertEquals("", x, y);
  }

  static public <A> A assertEquals(String msg, Object x, A y) {
    if (assertVerbose())
      return assertEqualsVerbose(msg, x, y);
    if (!(x == null ? y == null : x.equals(y)))
      throw fail((msg != null ? msg + ": " : "") + y + " != " + x);
    return y;
  }

  static public File getBytecodePathForClass(Object o) {
    return getBytecodePathForClass(_getClass(o));
  }

  static public File getBytecodePathForClass(Class c) {
    try {
      return c == null ? null : new File(c.getProtectionDomain().getCodeSource().getLocation().toURI());
    } catch (Exception __e) {
      throw rethrow(__e);
    }
  }

  static public File javaxDataDir_dir;

  static public File javaxDataDir() {
    return javaxDataDir_dir != null ? javaxDataDir_dir : new File(userHome(), "JavaX-Data");
  }

  static public File javaxDataDir(String... subs) {
    return newFile(javaxDataDir(), subs);
  }

  static public File newFile(File base, String... names) {
    for (String name : names) base = new File(base, name);
    return base;
  }

  static public File newFile(String name) {
    return name == null ? null : new File(name);
  }

  static public File newFile(String base, String... names) {
    return newFile(newFile(base), names);
  }

  static public boolean fileExists(String path) {
    return path != null && new File(path).exists();
  }

  static public boolean fileExists(File f) {
    return f != null && f.exists();
  }

  static public void createOrRemoveFile(File f, boolean create) {
    if (create) {
      if (!fileExists(f))
        touchFile(f);
    } else if (fileExists(f))
      removeFile(f);
  }

  static public List<String> tlft(String s) {
    return toLinesFullTrim(s);
  }

  static public List<String> tlft(File f) {
    return toLinesFullTrim(f);
  }

  static public String loadTextFile(String fileName) {
    return loadTextFile(fileName, null);
  }

  static public String loadTextFile(File f, String defaultContents) {
    return loadTextFile(f, defaultContents, "UTF-8");
  }

  static public String loadTextFile(File f, String defaultContents, String encoding) {
    try {
      checkFileNotTooBigToRead(f);
      if (f == null || !f.exists())
        return defaultContents;
      FileInputStream fileInputStream = new FileInputStream(f);
      InputStreamReader inputStreamReader = new InputStreamReader(fileInputStream, encoding);
      return loadTextFile(inputStreamReader);
    } catch (Exception __e) {
      throw rethrow(__e);
    }
  }

  public static String loadTextFile(File fileName) {
    return loadTextFile(fileName, null);
  }

  static public String loadTextFile(String fileName, String defaultContents) {
    return fileName == null ? defaultContents : loadTextFile(newFile(fileName), defaultContents);
  }

  static public String loadTextFile(Reader reader) throws IOException {
    StringBuilder builder = new StringBuilder();
    try {
      char[] buffer = new char[1024];
      int n;
      while (-1 != (n = reader.read(buffer))) builder.append(buffer, 0, n);
    } finally {
      reader.close();
    }
    return str(builder);
  }

  static public boolean sameFile(File a, File b) {
    try {
      return a == null ? b == null : b != null && eq(a.getCanonicalPath(), b.getCanonicalPath());
    } catch (Exception __e) {
      throw rethrow(__e);
    }
  }

  static public File dirOfFile(File f) {
    return f == null ? null : f.getParentFile();
  }

  static public String fileName(File f) {
    return f == null ? null : f.getName();
  }

  static public File saveTextFile(String fileName, String contents) throws IOException {
    File file = new File(fileName);
    mkdirsForFile(file);
    String tempFileName = fileName + "_temp";
    File tempFile = new File(tempFileName);
    if (contents != null) {
      if (tempFile.exists())
        try {
          String saveName = tempFileName + ".saved." + now();
          copyFile(tempFile, new File(saveName));
        } catch (Throwable e) {
          printStackTrace(e);
        }
      FileOutputStream fileOutputStream = newFileOutputStream(tempFile.getPath());
      OutputStreamWriter outputStreamWriter = new OutputStreamWriter(fileOutputStream, "UTF-8");
      PrintWriter printWriter = new PrintWriter(outputStreamWriter);
      printWriter.print(contents);
      printWriter.close();
    }
    if (file.exists() && !file.delete())
      throw new IOException("Can't delete " + fileName);
    if (contents != null)
      if (!tempFile.renameTo(file))
        throw new IOException("Can't rename " + tempFile + " to " + file);
    vmBus_send("wroteFile", file);
    return file;
  }

  static public File saveTextFile(File fileName, String contents) {
    try {
      saveTextFile(fileName.getPath(), contents);
      return fileName;
    } catch (Exception __e) {
      throw rethrow(__e);
    }
  }

  static public String lines(Iterable lines) {
    return fromLines(lines);
  }

  static public String lines(Object[] lines) {
    return fromLines(asList(lines));
  }

  static public List<String> lines(String s) {
    return toLines(s);
  }

  static public <A> String lines(Iterable<A> l, IF1<A, String> f) {
    return mapToLines(l, f);
  }

  static public <A> List<A> llNonNulls(A... a) {
    List<A> l = new ArrayList();
    for (A x : a) if (x != null)
      l.add(x);
    return l;
  }

  static public <A extends Component> A jMinHeight(A c, int h) {
    return jMinHeight(h, c);
  }

  static public <A extends Component> A jMinHeight(int h, A c) {
    Dimension size = c.getMinimumSize();
    c.setMinimumSize(new Dimension(size.width, max(h, size.height)));
    return jPreferHeight(h, c);
  }

  static public LinkedHashMap litorderedmap(Object... x) {
    LinkedHashMap map = new LinkedHashMap();
    litmap_impl(map, x);
    return map;
  }

  static public String or2_rev(String b, String a) {
    return or2(a, b);
  }

  static public String joinNemptiesWithSpacedPlus(Object... strings) {
    return joinNempties(" + ", strings);
  }

  static public String joinNemptiesWithSpacedPlus(Iterable strings) {
    return joinNempties(" + ", strings);
  }

  static public int intMax(Collection c, String field) {
    int max = Integer.MIN_VALUE;
    for (Object o : c) max = Math.max(max, toInt(getOpt(o, field)));
    return max;
  }

  static public int intMax(Iterable<Integer> l) {
    int max = Integer.MIN_VALUE;
    for (int i : unnullForIteration(l)) max = Math.max(max, i);
    return max;
  }

  static public int intMax(int... l) {
    int max = Integer.MIN_VALUE;
    if (l != null)
      for (int i : l) max = Math.max(max, i);
    return max;
  }

  static public List mapLL(Object f, Object... data) {
    return map(f, ll(data));
  }

  static public <A, B> List<B> mapLL(IF1<A, B> f, A... data) {
    return map(f, ll(data));
  }

  static public int linesOfCode_javaTok(String text) {
    List<String> tok = javaTok(text);
    int lines = 0;
    boolean codeInCurrentLine = false;
    for (int i = 0; i < l(tok); i++) {
      String t = tok.get(i);
      if (odd(i)) {
        int lTok = l(t);
        for (int j = 0; j < lTok; j++) {
          char c = t.charAt(j);
          if (c == '\n')
            codeInCurrentLine = false;
          else if (!isSpaceEtc(c) && !codeInCurrentLine) {
            codeInCurrentLine = true;
            ++lines;
          }
        }
      } else {
        if (codeInCurrentLine && containsNewLine(t))
          codeInCurrentLine = false;
      }
    }
    return lines;
  }

  static public File appendToFileName(File f, String suffix) {
    return fileAppendToName(f, suffix);
  }

  static public File appendToFileName(String suffix, File f) {
    return appendToFileName(f, suffix);
  }

  static public List map(Iterable l, Object f) {
    return map(f, l);
  }

  static public List map(Object f, Iterable l) {
    List x = emptyList(l);
    if (l != null)
      for (Object o : l) {
        ping();
        x.add(callF(f, o));
      }
    return x;
  }

  static public List map(Map map, Object f) {
    List x = new ArrayList();
    if (map != null)
      for (Object _e : map.entrySet()) {
        ping();
        Map.Entry e = (Map.Entry) _e;
        x.add(callF(f, e.getKey(), e.getValue()));
      }
    return x;
  }

  static public List map(Object f, Object[] l) {
    return map(f, asList(l));
  }

  static public List map(Object[] l, Object f) {
    return map(f, l);
  }

  static public List map(Object f, Map map) {
    return map(map, f);
  }

  static public <A, B> List<B> map(Iterable<A> l, F1<A, B> f) {
    return map(f, l);
  }

  static public <A, B> List<B> map(F1<A, B> f, Iterable<A> l) {
    List x = emptyList(l);
    if (l != null)
      for (A o : l) {
        ping();
        x.add(callF(f, o));
      }
    return x;
  }

  static public <A, B> List<B> map(IF1<A, B> f, Iterable<A> l) {
    return map(l, f);
  }

  static public <A, B> List<B> map(Iterable<A> l, IF1<A, B> f) {
    List x = emptyList(l);
    if (l != null)
      for (A o : l) {
        ping();
        x.add(f.get(o));
      }
    return x;
  }

  static public <A, B> List<B> map(IF1<A, B> f, A[] l) {
    return map(l, f);
  }

  static public <A, B> List<B> map(A[] l, IF1<A, B> f) {
    List x = emptyList(l);
    if (l != null)
      for (A o : l) {
        ping();
        x.add(f.get(o));
      }
    return x;
  }

  static public <A, B, C> List<C> map(Map<A, B> map, IF2<A, B, C> f) {
    List x = new ArrayList();
    if (map != null)
      for (Map.Entry<A, B> e : map.entrySet()) {
        ping();
        x.add(f.get(e.getKey(), e.getValue()));
      }
    return x;
  }

  static public <A, B> List<A> map(IF1<A, B> f, A data1, A... moreData) {
    List x = emptyList(l(moreData) + 1);
    x.add(f.get(data1));
    if (moreData != null)
      for (A o : moreData) {
        ping();
        x.add(f.get(o));
      }
    return x;
  }

  static public String nLabels(long n) {
    return n2(n, "label");
  }

  static public String nLabels(Collection l) {
    return nLabels(l(l));
  }

  static public String nLabels(Map map) {
    return nLabels(l(map));
  }

  static public boolean containsNewLine(String s) {
    return contains(s, '\n');
  }

  static public <A extends Concept> A uniqCI(Class<A> c, Object... params) {
    return uniqueConcept(db_mainConcepts(), c, params);
  }

  static public <A extends Concept> A uniqCI(Concepts cc, Class<A> c, Object... params) {
    AutoCloseable __1 = tempDBLock(cc);
    try {
      params = expandParams(c, params);
      A x = findConceptWhereCI(cc, c, params);
      if (x == null) {
        x = unlisted(c);
        csetAll(x, params);
        cc.register(x);
      }
      return x;
    } finally {
      _close(__1);
    }
  }

  static public File conceptsDir() {
    return conceptsDir(db_mainConcepts());
  }

  static public File conceptsDir(Concepts cc) {
    return cc.conceptsDir();
  }

  static public File conceptsDir(String subName) {
    return conceptsDir(db_mainConcepts(), subName);
  }

  static public File conceptsDir(Concepts cc, String subName) {
    return newFile(conceptsDir(cc), subName);
  }

  static public boolean containsFile(File dir, String name) {
    return new File(dir, name).exists();
  }

  static public boolean containsFile(Iterable<File> l, File f) {
    return any(l, file -> sameFile(f, file));
  }

  static public File conceptsFile(String progID) {
    return getProgramFile(progID, conceptsFileName());
  }

  static public File conceptsFile() {
    return conceptsFile(dbProgramID());
  }

  static public File conceptsFile(Concepts concepts) {
    return concepts.conceptsFile();
  }

  static public File conceptsFileIn(File dir) {
    return newFile(dir, conceptsFileName());
  }

  static public List<File> listDirsContainingFileNamed(File dir, String fileName) {
    return filter(listDirs(dir), d -> isFile(newFile(d, fileName)));
  }

  static public boolean cleanUp_interruptThreads = false;

  static public void cleanUp(Object c) {
    if (c == null)
      return;
    if (c instanceof AutoCloseable) {
      close_pcall((AutoCloseable) c);
      return;
    }
    if (c instanceof java.util.Timer) {
      ((java.util.Timer) c).cancel();
      return;
    }
    if (c instanceof Collection) {
      cleanUp((Collection) c);
      return;
    }
    if (c instanceof Map) {
      for (Object o : keys((Map) c)) cleanUp(o);
      for (Object o : values((Map) c)) cleanUp(o);
      ((Map) c).clear();
      return;
    }
    try {
      preCleanUp(c);
      setOpt_raw(c, "ping_pauseAll", false);
      innerCleanUp(c);
      List androids = (List) getOpt(c, "record_list");
      for (Object android : unnull(androids)) pcallOpt(android, "dispose");
      List<WeakReference> classes = (List<WeakReference>) (getOpt(c, "hotwire_classes"));
      if (classes != null)
        for (WeakReference cc : classes) {
          try {
            cleanUp(cc.get());
          } catch (Throwable __e) {
            printStackTrace(__e);
          }
        }
      if (cleanUp_interruptThreads) {
        List<Thread> threads = registeredThreads(c);
        if (nempty(threads)) {
          print("cleanUp: Interrupting " + n2(threads, "thread") + ": " + joinWithComma(allToString(threads)));
          interruptThreads(threads);
        }
      }
    } catch (Throwable __e) {
      printStackTrace(__e);
    }
    setOpt_raw(c, "cleaningUp_flag", false);
    if (c instanceof Class && ((Class) c).getName().equals("main"))
      retireClassLoader(((Class) c).getClassLoader());
  }

  static public void cleanUp(Collection l) {
    if (l == null)
      return;
    for (Object c : l) cleanUp(c);
    l.clear();
  }

  static public <A extends Concept> A conceptWhere(Class<A> c, Object... params) {
    return findConceptWhere(c, params);
  }

  static public <A extends Concept> A conceptWhere(Concepts cc, Class<A> c, Object... params) {
    return findConceptWhere(cc, c, params);
  }

  static public <A extends Concept> A optimizedUniq(Class<A> c, Object... params) {
    return optimizedUniq(db_mainConcepts(), c, params);
  }

  static public <A extends Concept> A optimizedUniq(Concepts cc, Class<A> c, Object... params) {
    {
      var __1 = conceptWhere(cc, c, params);
      if (__1 != null)
        return __1;
    }
    return uniq(cc, c, params);
  }

  static public <A> A waitUntilNotNull(Var<A> v) {
    return waitForVarToBeNotNull(v);
  }

  static public <A> A waitUntilNotNull(IVarWithNotify<A> v) {
    Var<A> myVar = new Var();
    AutoCloseable __1 = tempOnChangeAndNow(v, () -> myVar.set(v.get()));
    try {
      return waitUntilNotNull(myVar);
    } finally {
      _close(__1);
    }
  }

  static public <A> A waitUntilNotNull(VarWithNotify<A> v) {
    return waitUntilNotNull((Var<A>) v);
  }

  static public Double toDoubleOrNull(Object o) {
    if (o == null)
      return null;
    if (o instanceof Number)
      return ((Number) o).doubleValue();
    if (o instanceof BigInteger)
      return ((BigInteger) o).doubleValue();
    if (o instanceof String)
      return parseDouble((String) o);
    return null;
  }

  static public Concept getConcept(long id) {
    return db_mainConcepts().getConcept(id);
  }

  static public Concept getConcept(Concepts concepts, long id) {
    return concepts.getConcept(id);
  }

  static public <A extends Concept> A getConcept(Class<A> cc, long id) {
    return getConcept(db_mainConcepts(), cc, id);
  }

  static public <A extends Concept> A getConcept(Concepts concepts, Class<A> cc, long id) {
    Concept c = concepts.getConcept(id);
    if (c == null)
      return null;
    if (!isInstance(cc, c))
      throw fail("Can't convert concept: " + getClassName(c) + " -> " + getClassName(cc) + " (" + id + ")");
    return (A) c;
  }

  static public double infinity() {
    return positiveInfinity();
  }

  static public <A> A evalWithTimeoutOrTypedException(int timeoutMS, IF0<A> f) {
    return evalWithTimeoutOrTypedException(toSeconds(timeoutMS), f);
  }

  static public <A> A evalWithTimeoutOrTypedException(double timeoutSeconds, IF0<A> f) {
    Either<A, Thread> e = evalWithTimeout(timeoutSeconds, f);
    if (e.isA())
      return (A) e.a();
    throw new TimeoutException_Inner(timeoutSeconds, f, e.b());
  }

  static public void cancelThread(Thread t) {
    if (t == null)
      return;
    ping();
    synchronized (ping_actions) {
      ping_actions.put(t, "cancelled");
      ping_anyActions = true;
    }
  }

  static public Object dm_os() {
    {
      var __1 = vm_generalMap_get("stefansOS");
      if (__1 != null)
        return __1;
    }
    return creator();
  }

  static public boolean isSameFile(File a, File b) {
    return sameFile(a, b);
  }

  static public String md5(String text) {
    try {
      if (text == null)
        return "-";
      return bytesToHex(md5_impl(toUtf8(text)));
    } catch (Exception __e) {
      throw rethrow(__e);
    }
  }

  static public String md5(byte[] data) {
    if (data == null)
      return "-";
    return bytesToHex(md5_impl(data));
  }

  static public byte[] md5_impl(byte[] data) {
    try {
      return MessageDigest.getInstance("MD5").digest(data);
    } catch (Exception __e) {
      throw rethrow(__e);
    }
  }

  static public String md5(File file) {
    return md5OfFile(file);
  }

  static public org.apache.bcel.generic.Type classToBCELType(Class c) {
    if (c == null)
      return null;
    if (isPrimitiveType(c)) {
      if (c == byte.class)
        return org.apache.bcel.generic.Type.BYTE;
      if (c == int.class)
        return org.apache.bcel.generic.Type.INT;
      if (c == double.class)
        return org.apache.bcel.generic.Type.DOUBLE;
      if (c == void.class)
        return org.apache.bcel.generic.Type.VOID;
      if (c == boolean.class)
        return org.apache.bcel.generic.Type.BOOLEAN;
      throw fail("TODO: classToBCELType " + c);
    }
    if (isArrayType(c)) {
      int dimensions = 0;
      while (c.isArray()) {
        ++dimensions;
        c = c.componentType();
      }
      return new ArrayType(classToBCELType(c), dimensions);
    }
    return new ObjectType(className(c));
  }

  static public Object[] repArray(Object a, int n) {
    return arrayrep(a, n);
  }

  static public <A> A[] repArray(Class<A> type, A a, int n) {
    return arrayrep(type, a, n);
  }

  static public java.util.Timer doLater(long delay, final Object r) {
    ping();
    final java.util.Timer timer = new java.util.Timer();
    timer.schedule(timerTask(r, timer), delay);
    return vmBus_timerStarted(timer);
  }

  static public java.util.Timer doLater(double delaySeconds, final Object r) {
    return doLater(toMS(delaySeconds), r);
  }

  static public Timestamp tsNow() {
    return new Timestamp();
  }

  static public boolean eqOrEqic(boolean caseInsensitive, String a, String b) {
    return caseInsensitive ? eqic(a, b) : eq(a, b);
  }

  static public boolean containsLineBreak(String s) {
    return containsNewLine(s);
  }

  static public boolean warn_on = true;

  static public ThreadLocal<List<String>> warn_warnings = new ThreadLocal();

  static public void warn(String s) {
    if (warn_on)
      print("Warning: " + s);
  }

  static public void warn(String s, List<String> warnings) {
    warn(s);
    if (warnings != null)
      warnings.add(s);
    addToCollection(warn_warnings.get(), s);
  }

  static public String joinNemptiesWithComma(Object... strings) {
    return joinNempties(", ", strings);
  }

  static public String joinNemptiesWithComma(Iterable strings) {
    return joinNempties(", ", strings);
  }

  static public long incAtomicLong(AtomicLong l) {
    return l.incrementAndGet();
  }

  static public PingSource pingSource() {
    return pingSource_tl().get();
  }

  static public PingSource pingSource(Thread thread) {
    return pingSource_tl().get(thread);
  }

  static public String[] toStringArray(Collection<String> c) {
    String[] a = new String[l(c)];
    Iterator<String> it = c.iterator();
    for (int i = 0; i < l(a); i++) a[i] = it.next();
    return a;
  }

  static public String[] toStringArray(Object o) {
    if (o instanceof String[])
      return (String[]) o;
    else if (o instanceof Collection)
      return toStringArray((Collection<String>) o);
    else
      throw fail("Not a collection or array: " + getClassName(o));
  }

  static public boolean preciseNuObject_debug = false;

  static public <A> A preciseNuObject(Class<A> c, Object... args) {
    try {
      Constructor[] methods = getDeclaredConstructors_cached(c);
      if (methods.length == 0)
        throw fail(c + " doesn't define any constructors");
      return preciseNuObject(methods, args);
    } catch (Exception __e) {
      throw rethrow(__e);
    }
  }

  static public <A> A preciseNuObject(Constructor[] methods, Object... args) {
    try {
      Constructor best = null;
      int bestScore = Integer.MAX_VALUE;
      boolean widening = false;
      if (preciseNuObject_debug)
        printVars("preciseNuObject", "c", first(methods).getDeclaringClass(), "methods", l(methods));
      for (var m : methods) {
        int score = methodApplicabilityScore_withPrimitiveWidening(m, args);
        if (score == 0)
          return (A) m.newInstance(args);
        if (preciseNuObject_debug)
          print("Method score: " + m + " " + score);
        if (abs(score) < bestScore) {
          best = m;
          bestScore = abs(score);
          widening = score < 0;
        }
      }
      if (best != null)
        if (widening)
          return (A) invokeConstructorWithWidening(best, args);
        else
          return (A) best.newInstance(args);
      methodSearch: for (var m : methods) {
        {
          if (!(m.isVarArgs()))
            continue;
        }
        Object[] newArgs = massageArgsForVarArgsCall(m, args);
        if (newArgs != null)
          return (A) m.newInstance(newArgs);
      }
      var c = first(methods).getDeclaringClass();
      throw fail("No matching constructor found: " + formatFunctionCall(c, map(__76 -> _getClass(__76), args)));
    } catch (Exception __e) {
      throw rethrow(__e);
    }
  }

  static public <A> Object[] mapToArrayOrNull(A[] l, IF1<A, Object> f) {
    if (l == null)
      return null;
    int n = l.length;
    if (n == 0)
      return null;
    Object[] array = new Object[n];
    for (int i = 0; i < n; i++) array[i] = f.get(l[i]);
    return array;
  }

  static public <A> Object[] mapToArrayOrNull(IF1<A, Object> f, A[] l) {
    return mapToArrayOrNull(l, f);
  }

  static public <A> Object[] mapToArrayOrNull(IF1<A, Object> f, Collection<A> l) {
    int n = l(l);
    if (n == 0)
      return null;
    Object[] array = new Object[n];
    if (n != 0) {
      Iterator it = iterator(l);
      for (int i = 0; i < n; i++) array[i] = callF(f, it.next());
    }
    return array;
  }

  static public <A> Object[] mapToArrayOrNull(Collection<A> l, IF1<A, Object> f) {
    return mapToArrayOrNull(l, f);
  }

  static public String formatFunctionCall(String fname, Object... args) {
    return formatFunctionCall((Object) fname, args);
  }

  static public String formatFunctionCall(Object fname, Object... args) {
    return fname + "(" + joinWithComma(allToString(args)) + ")";
  }

  static public String formatFunctionCall(String fname, Iterable args) {
    return formatFunctionCall((Object) fname, args);
  }

  static public String formatFunctionCall(Object fname, Iterable args) {
    return formatFunctionCall(fname, toObjectArray(args));
  }

  static public String resolve(String host) {
    return hostToIP(host);
  }

  static public String strOrClassName(Object o) {
    if (o instanceof Class)
      return className((Class) o);
    return str(o);
  }

  static public boolean newPreciseCall_debug = false;

  static public Object newPreciseCall(Object o, String method, Object... args) {
    try {
      if (o == null)
        return null;
      boolean staticCall = o instanceof Class;
      Class c = staticCall ? (Class) o : o.getClass();
      Object target = staticCall ? null : o;
      _MethodCache cache = callOpt_getCache(c);
      List<Method> methods = cache.cache.get(method);
      Method best = null;
      int bestScore = Integer.MAX_VALUE;
      boolean widening = false;
      if (newPreciseCall_debug)
        printVars("newPreciseCall", "method", method, "staticCall", staticCall, "c", c, "methods", l(methods));
      if (methods != null)
        for (Method m : methods) {
          if (staticCall && !isStaticMethod(m))
            continue;
          int score = methodApplicabilityScore_withPrimitiveWidening(m, args);
          if (score == 0)
            return invokeMethod(m, target, args);
          if (newPreciseCall_debug)
            print("Method score: " + m + " " + score);
          if (abs(score) < bestScore) {
            best = m;
            bestScore = abs(score);
            widening = score < 0;
          }
        }
      if (best != null)
        if (widening)
          return invokeMethodWithWidening(best, target, args);
        else
          return invokeMethod(best, target, args);
      return callWithVarargs(o, method, args);
    } catch (Exception __e) {
      throw rethrow(__e);
    }
  }

  static public Method findMethod_precise_onTypes(Object o, String method, Class... argTypes) {
    try {
      if (o instanceof Class) {
        _MethodCache cache = callOpt_getCache((Class) o);
        List<Method> methods = cache.cache.get(method);
        Lowest<Method> best = new Lowest();
        if (methods != null)
          for (Method m : methods) {
            {
              if (!(isStaticMethod(m)))
                continue;
            }
            int score = methodApplicabilityScore_onTypes(m, argTypes);
            if (score < Integer.MAX_VALUE)
              best.put(m, score);
          }
        return best.get();
      }
      if (o == null)
        return null;
      _MethodCache cache = callOpt_getCache(o.getClass());
      List<Method> methods = cache.cache.get(method);
      Lowest<Method> best = new Lowest();
      if (methods != null)
        for (Method m : methods) {
          int score = methodApplicabilityScore_onTypes(m, argTypes);
          if (score < Integer.MAX_VALUE)
            best.put(m, score);
        }
      return best.get();
    } catch (Exception __e) {
      throw rethrow(__e);
    }
  }

  static public Method findSingleInterfaceMethodOrFail(Class intrface) {
    Method m = findSingleInterfaceMethod(intrface);
    if (m == null)
      throw fail(intrface + " is not a single method interface");
    return m;
  }

  static public <A> A proxyFromInvocationHandler(Class<A> intrface, InvocationHandler handler) {
    return (A) java.lang.reflect.Proxy.newProxyInstance(intrface.getClassLoader(), new Class[] { intrface }, handler);
  }

  static public Object handleObjectMethodsInProxyInvocationHandler(Object invocationHandler, Method implementedMethod, Method method, Object proxy, Object[] actualArgs) {
    String name = method.getName();
    if (name.equals("hashCode"))
      return invocationHandler.hashCode();
    if (name.equals("equals"))
      return proxy == actualArgs[0];
    if (name.equals("toString"))
      return invocationHandler.toString();
    throw fail("No handler for method " + method + " (only have " + implementedMethod + ")");
  }

  static public Object[] concatMethodArgs(Object[] args1, Object[] args2) {
    int n1, n2;
    if (args1 == null || (n1 = args1.length) == 0)
      return args2;
    if (args2 == null || (n2 = args2.length) == 0)
      return args1;
    Object[] args = new Object[n1 + n2];
    for (int i = 0; i < n1; i++) args[i] = args1[i];
    for (int i = 0; i < n2; i++) args[n1 + i] = args2[i];
    return args;
  }

  static public Iterator iterator_gen(Object o) {
    if (o == null)
      return emptyItIt();
    if (o instanceof Iterator)
      return ((Iterator) o);
    if (o instanceof Iterable)
      return ((Iterable) o).iterator();
    if (o instanceof Object[])
      return arrayIterator((Object[]) o);
    throw fail("Not iterable: " + className(o));
  }

  static public class mapI_It extends IterableIterator {

    public Object f;

    public Iterator i;

    public mapI_It() {
    }

    public mapI_It(Object f, Iterator i) {
      this.i = i;
      this.f = f;
    }

    public boolean hasNext() {
      return i.hasNext();
    }

    public Object next() {
      return callF(f, i.next());
    }

    public String toString() {
      return formatFunctionCall("mapI", f, i);
    }
  }

  static public IterableIterator mapI(final Object f, final Iterator i) {
    return new mapI_It(f, i);
  }

  static public IterableIterator mapI(IterableIterator i, Object f) {
    return mapI((Iterator) i, f);
  }

  static public IterableIterator mapI(Object f, IterableIterator i) {
    return mapI((Iterator) i, f);
  }

  static public IterableIterator mapI(Iterator i, Object f) {
    return mapI(f, i);
  }

  static public <A, B> IterableIterator<B> mapI(Iterable<A> i, IF1<A, B> f) {
    return new MapI(f, iterator(i));
  }

  static public <A, B> IterableIterator<B> mapI(Iterator<A> i, IF1<A, B> f) {
    return new MapI(f, i);
  }

  static public <A, B> IterableIterator<B> mapI(IterableIterator<A> i, IF1<A, B> f) {
    return new MapI(f, i);
  }

  static public <A, B> IterableIterator<B> mapI(IF1<A, B> f, Iterable<A> i) {
    return new MapI(f, iterator(i));
  }

  static public IterableIterator mapI(Iterable i, Object f) {
    return mapI(f, i.iterator());
  }

  static public IterableIterator mapI(Object f, Iterable i) {
    return mapI(i, f);
  }

  static public <A, B, C extends Iterator<B>> IterableIterator<B> nestedIterator(Iterable<A> c, final F1<A, C> makeInnerIterator) {
    return nestedIterator(iterator(c), makeInnerIterator);
  }

  static public <A, B, C extends Iterator<B>> IterableIterator<B> nestedIterator(Iterable<A> c, IF1<A, C> makeInnerIterator) {
    return nestedIterator(iterator(c), makeInnerIterator);
  }

  static public <A, B, C extends Iterator<B>> IterableIterator<B> nestedIterator(IterableIterator<A> c, IF1<A, C> makeInnerIterator) {
    return nestedIterator((Iterator<A>) c, makeInnerIterator);
  }

  static public <A, B, C extends Iterator<B>> IterableIterator<B> nestedIterator(Iterator<A> it1, IF1<A, C> makeInnerIterator) {
    if (it1 == null || !it1.hasNext())
      return emptyItIt();
    return iff(new F0() {

      public A a;

      public Iterator<B> innerIterator;

      {
        nextOuter();
      }

      public void nextOuter() {
        a = it1.next();
        innerIterator = makeInnerIterator.get(a);
      }

      public Object get() {
        while (true) {
          ping();
          if (innerIterator != null && innerIterator.hasNext())
            return innerIterator.next();
          if (!it1.hasNext())
            return endMarker();
          nextOuter();
        }
      }
    });
  }

  static public <A, B, C extends Iterator<B>> IterableIterator<B> nestedIterator(final Iterator<A> it1, F1<A, C> makeInnerIterator) {
    if (it1 == null || !it1.hasNext())
      return emptyItIt();
    return iff(new F0() {

      public A a;

      public Iterator<B> innerIterator;

      {
        nextOuter();
      }

      public void nextOuter() {
        a = it1.next();
        innerIterator = makeInnerIterator.get(a);
      }

      public Object get() {
        while (true) {
          ping();
          if (innerIterator != null && innerIterator.hasNext())
            return innerIterator.next();
          if (!it1.hasNext())
            return endMarker();
          nextOuter();
        }
      }
    });
  }

  static public <A, B, C extends Iterator<B>> IterableIterator<B> nestedIterator(IF1<A, C> makeInnerIterator, Iterator<A> it1) {
    return nestedIterator(it1, makeInnerIterator);
  }

  static public <A, B, C extends Iterator<B>> IterableIterator<B> nestedIterator(IF1<A, C> makeInnerIterator, Collection<A> l) {
    return nestedIterator(l, makeInnerIterator);
  }

  static public <A extends JSpinner> A onChange(A spinner, Object r) {
    return onChange(spinner, toRunnable(r));
  }

  static public <A extends JSpinner> A onChange(A spinner, Runnable r) {
    if (r != null) {
      swing(() -> {
        spinner.addChangeListener(changeListener(r));
      });
    }
    return spinner;
  }

  static public <A extends AbstractButton> A onChange(A b, Object r) {
    {
      swing(() -> {
        b.addItemListener(itemListener(r));
      });
    }
    return b;
  }

  static public void onChange(JTextComponent tc, Object r) {
    onUpdate(tc, r);
  }

  static public void onChange(JTextComponent tc, Runnable r) {
    onUpdate(tc, r);
  }

  static public <A extends JSlider> A onChange(A slider, final Object r) {
    {
      swing(() -> {
        slider.addChangeListener(changeListener(r));
      });
    }
    return slider;
  }

  static public <A> JComboBox<A> onChange(JComboBox<A> cb, Runnable r) {
    addActionListener(cb, r);
    return cb;
  }

  static public <A> JComboBox<A> onChange(JComboBox<A> cb, IVF1<A> f) {
    if (f != null)
      addActionListener(cb, () -> f.get(getSelectedItem_typed(cb)));
    return cb;
  }

  static public JComboBox onChange(Object r, JComboBox cb) {
    return onChange(cb, r);
  }

  static public JComboBox onChange(JComboBox cb, final Object r) {
    if (isEditableComboBox(cb))
      onChange(textFieldFromComboBox(cb), r);
    else
      onSelectedItem(cb, new VF1<String>() {

        public void get(String s) {
          try {
            callF(r);
          } catch (Exception __e) {
            throw rethrow(__e);
          }
        }

        public String toString() {
          return "callF(r)";
        }
      });
    return cb;
  }

  static public <A extends JTabbedPane> A onChange(A tabs, Runnable r) {
    {
      swing(() -> {
        tabs.addChangeListener(changeListener(r));
      });
    }
    return tabs;
  }

  static public <A extends JColorChooser> A onChange(Runnable r, A cc) {
    if (cc != null && r != null) {
      swing(() -> {
        cc.getSelectionModel().addChangeListener(changeListener(r));
      });
    }
    return cc;
  }

  static public void onChange(IHasChangeListeners a, ChangeTriggerable b) {
    if (a != null && b != null)
      a.onChange(new ChangeTrigger(b));
  }

  static public void onChangeAndNow(JComponent c, Object r) {
    onUpdateAndNow(c, r);
  }

  static public void onChangeAndNow(List<? extends JComponent> l, Object r) {
    onUpdateAndNow(l, r);
  }

  static public void onChangeAndNow(JTextComponent c, IVF1<String> r) {
    onUpdateAndNow(c, r);
  }

  static public <A> JComboBox<A> onChangeAndNow(JComboBox<A> cb, IVF1<A> f) {
    onChange(cb, f);
    {
      if (f != null)
        f.get(getSelectedItem_typed(cb));
    }
    return cb;
  }

  static public <A extends JTabbedPane> A onChangeAndNow(A tabs, Runnable r) {
    if (r != null) {
      onChange(tabs, r);
      r.run();
    }
    return tabs;
  }

  static public File byteCodePathForClass(Class c) {
    if (c == null)
      return null;
    ClassLoader cl = getClassLoader(c);
    Collection<File> files = (Collection<File>) (getOpt(cl, "files"));
    if (files != null) {
      String name = c.getName().replace('.', '/') + ".class";
      for (File location : files) if (dirOrZipContainsPath(location, name))
        return location;
      throw fail(name + " not found in: " + files);
    }
    return null;
  }

  static public File byteCodePathForClass(Object o) {
    return byteCodePathForClass(_getClass(o));
  }

  static public <A> List<A> itemPlusList(A a, Collection<A> l) {
    return concatLists(ll(a), l);
  }

  static public List<String> endingWith_dropSuffix(Collection<String> l, String suffix) {
    List<String> out = new ArrayList();
    for (String s : unnullForIteration(l)) if (endsWith(s, suffix))
      out.add(dropLast(l(suffix), s));
    return out;
  }

  static public List<String> endingWith_dropSuffix(String suffix, Collection<String> l) {
    return endingWith_dropSuffix(l, suffix);
  }

  static public List<String> standardImports_cache;

  static public List<String> standardImports() {
    if (standardImports_cache == null)
      standardImports_cache = standardImports_load();
    return standardImports_cache;
  }

  static public List<String> standardImports_load() {
    return ll("java.util.*", "java.util.zip.*", "java.util.List", "java.util.regex.*", "java.util.concurrent.*", "java.util.concurrent.atomic.*", "java.util.concurrent.locks.*", "java.util.function.*", "javax.swing.*", "javax.swing.event.*", "javax.swing.text.*", "javax.swing.table.*", "java.io.*", "java.net.*", "java.lang.reflect.*", "java.lang.ref.*", "java.lang.management.*", "java.security.*", "java.security.spec.*", "java.awt.*", "java.awt.event.*", "java.awt.image.*", "java.awt.geom.*", "javax.imageio.*", "java.math.*", "java.time.Duration");
  }

  static public List<String> classNamesInJarOrDir(File dir) {
    return classNamesInJarOrDir(dir, "");
  }

  static public List<String> classNamesInJarOrDir(File dir, String prefixInJar) {
    List<String> classes = new ArrayList();
    if (dir == null) {
    } else if (dir.isDirectory()) {
      for (File f : listFiles(dir)) {
        String s = f.getName();
        if (s.endsWith(".class"))
          classes.add(dropSuffix(".class", s));
      }
    } else if (dir.isFile()) {
      try {
        JarFile jarFile = new JarFile(dir);
        try {
          Enumeration<JarEntry> e = jarFile.entries();
          while (e.hasMoreElements()) {
            JarEntry je = e.nextElement();
            if (je.isDirectory() || je.getName().startsWith("META-INF/") || !je.getName().endsWith(".class"))
              continue;
            String className = dropSuffix(".class", je.getName());
            className = dropPrefixOrNull(prefixInJar, className);
            if (className == null)
              continue;
            if (className.contains("-"))
              continue;
            className = className.replace('/', '.');
            classes.add(className);
          }
        } finally {
          jarFile.close();
        }
      } catch (Throwable __e) {
        printStackTrace(__e);
      }
    }
    return classes;
  }

  static public List<String> classNamesInLoadedJigsawModules() {
    return concatMap(loadedJigsawModuleNames(), moduleName -> classNamesInJigsawModule(moduleName));
  }

  static public long now_virtualTime;

  static public long now() {
    return now_virtualTime != 0 ? now_virtualTime : System.currentTimeMillis();
  }

  static public String formatLocalDateWithSeconds(long time) {
    return localDateWithSeconds(time);
  }

  static public String formatLocalDateWithSeconds() {
    return localDateWithSeconds();
  }

  static public long toMS(double seconds) {
    return (long) (seconds * 1000);
  }

  static public long clockTimeToSystemTime(long now) {
    return now == 0 ? 0 : now + clockToSysTimeDiff();
  }

  static public <A, B extends A> void addAll(Collection<A> c, Iterable<B> b) {
    if (c != null && b != null)
      for (A a : b) c.add(a);
  }

  static public <A, B extends A> boolean addAll(Collection<A> c, Collection<B> b) {
    return c != null && b != null && c.addAll(b);
  }

  static public <A, B extends A> boolean addAll(Collection<A> c, B... b) {
    return c != null && b != null && c.addAll(Arrays.asList(b));
  }

  static public <A, B> Map<A, B> addAll(Map<A, B> a, Map<? extends A, ? extends B> b) {
    if (a != null && b != null)
      a.putAll(b);
    return a;
  }

  static public <A extends Container> A addAll(A c, Collection<? extends Component> components) {
    return addComponents(c, components);
  }

  static public <A extends Container> A addAll(A c, Component... components) {
    return addComponents(c, components);
  }

  static public <A> List<A> listPlus(Collection<A> l, A... more) {
    return concatLists(l, asList(more));
  }

  static public void change() {
    callOpt(getOptMC("mainConcepts"), "allChanged");
  }

  static public void cMigrateField(Concept c, String oldField, String newField) {
    if (c == null)
      return;
    Object oldValue = cget(c, oldField);
    Object newValue = cget(c, newField);
    if (oldValue != null && newValue == null) {
      try {
        String name = shortDynName(c);
        print("Migrating " + name + "." + oldField + " -> " + name + "." + newField + " [id " + c.id + "]");
        cset(c, newField, oldValue);
        cset(c, oldField, null);
      } catch (Throwable __e) {
        printStackTrace(__e);
      }
    }
  }

  static public String shortDynName(Object o) {
    return shortDynamicClassName(o);
  }

  static public String nLines(long n) {
    return n2(n, "line");
  }

  static public String nLines(Collection l) {
    return nLines(l(l));
  }

  static public String nLines(String s) {
    return nLines(countLines(s));
  }

  static public String nChars(long n) {
    return n2(n, "char");
  }

  static public String nChars(String s) {
    return nChars(l(s));
  }

  static public String indentx(Object s) {
    return indentx(strOrEmpty(s));
  }

  static public String indentx(String s) {
    return indentx(indent_default, s);
  }

  static public String indentx(int n, String s) {
    return dropSuffix(repeat(' ', n), indent(n, s));
  }

  static public String indentx(String indent, String s) {
    return dropSuffix(indent, indent(indent, s));
  }

  static public void appendToTextFile(File file, String s) {
    appendToFile(file, s);
  }

  static public void appendToTextFile(String file, String s) {
    appendToTextFile(programFile(file), s);
  }

  static public String dateWithMSUTC() {
    return dateWithMSUTC(now());
  }

  static public String dateWithMSUTC(long time) {
    var format = simpleDateFormat_UTC("yyyy/MM/dd");
    return format.format(time) + " " + formatUTCWithMS_24(time);
  }

  static public String firstToUpper(String s) {
    if (empty(s))
      return s;
    return Character.toUpperCase(s.charAt(0)) + s.substring(1);
  }

  static public <A> A getVar(IF0<A> v) {
    return v == null ? null : v.get();
  }

  static public <A> A getVar(Optional<A> v) {
    return v == null ? null : v.orElse(null);
  }

  static public String appendBracketed(Object o) {
    String b = strOrNull(o);
    return empty(b) ? "" : "" + " (" + b + ")";
  }

  static public String appendBracketed(String a, String b) {
    return a + appendBracketed(b);
  }

  static public String appendPrefixIfNempty(String prefix, String s) {
    return prependIfNempty(prefix, s);
  }

  static public <A> ArrayList<A> toList(A[] a) {
    return asList(a);
  }

  static public ArrayList<Integer> toList(int[] a) {
    return asList(a);
  }

  static public <A> ArrayList<A> toList(Set<A> s) {
    return asList(s);
  }

  static public <A> ArrayList<A> toList(Iterable<A> s) {
    return asList(s);
  }

  static public <A, B> B firstValue(Map<A, B> map) {
    return first(values(map));
  }

  static public <A, B> B firstValue(MultiSetMap<A, B> map) {
    return map == null ? null : first(firstValue(map.data));
  }

  static public <A, B> B firstValue(MultiMap<A, B> map) {
    return map == null ? null : first(firstValue(map.data));
  }

  static public void pcallFAll(Collection l, Object... args) {
    if (l != null)
      for (Object f : cloneList(l)) pcallF(f, args);
  }

  static public void pcallFAll(Iterator it, Object... args) {
    while (it.hasNext()) pcallF(it.next(), args);
  }

  static public <A, B> A firstKey(Map<A, B> map) {
    return first(keys(map));
  }

  static public <A, B> A firstKey(IMultiMap<A, B> map) {
    return map == null ? null : first(map.keySet());
  }

  static public boolean containsInstance(Iterable i, Class c) {
    if (i != null)
      for (Object o : i) if (isInstanceX(c, o))
        return true;
    return false;
  }

  static public void register(Concept c) {
    registerConcept(c);
  }

  static public <A extends JComponent> A setToolTip(A c, Object toolTip) {
    return setToolTipText(c, toolTip);
  }

  static public <A extends JComponent> A setToolTip(Object toolTip, A c) {
    return setToolTipText(c, toolTip);
  }

  static public void setToolTip(TrayIcon trayIcon, String toolTip) {
    setTrayIconToolTip(trayIcon, toolTip);
  }

  static public <A> A _get(List<A> l, int idx) {
    return l != null && idx >= 0 && idx < l(l) ? l.get(idx) : null;
  }

  static public Object _get(Object o, String field) {
    return get(o, field);
  }

  static public Object _get(String field, Object o) {
    return get(o, field);
  }

  static public <A> A _get(A[] l, int idx) {
    return idx >= 0 && idx < l(l) ? l[idx] : null;
  }

  static public <A extends Concept> List<A> list(Class<A> type) {
    return list(type, db_mainConcepts());
  }

  static public <A extends Concept> List<A> list(Class<A> type, Concepts cc) {
    return cc.list(type);
  }

  static public <A extends Concept> List<A> list(Concepts concepts, Class<A> type) {
    return concepts.list(type);
  }

  static public List<Concept> list(String type) {
    return db_mainConcepts().list(type);
  }

  static public List<Concept> list(Concepts concepts, String type) {
    return concepts.list(type);
  }

  static public List<Concept> list(Concepts concepts) {
    return asList(concepts.allConcepts());
  }

  static public Constructor findConstructor_precise_onTypes(Class c, Class... argTypes) {
    try {
      List<Constructor> ctors = constructorsWithNumberOfArguments(c, l(argTypes));
      Lowest<Constructor> best = new Lowest();
      if (ctors != null)
        for (Constructor ctor : ctors) {
          int score = methodApplicabilityScore_onTypes(ctor, argTypes);
          if (score < Integer.MAX_VALUE)
            best.put(ctor, score);
        }
      return best.get();
    } catch (Exception __e) {
      throw rethrow(__e);
    }
  }

  static public void add(BitSet bs, int i) {
    bs.set(i);
  }

  static public <A> boolean add(Collection<A> c, A a) {
    return c != null && c.add(a);
  }

  static public void add(Container c, Component x) {
    addToContainer(c, x);
  }

  static public long add(AtomicLong l, long b) {
    return l.addAndGet(b);
  }

  static public Method findNonStaticMethod_precise_onTypes(Object o, String method, Class... argTypes) {
    try {
      Class c = _getClass(o);
      if (c == null)
        return null;
      _MethodCache cache = callOpt_getCache(c);
      List<Method> methods = cache.cache.get(method);
      Lowest<Method> best = new Lowest();
      if (methods != null)
        for (Method m : methods) {
          {
            if (isStaticMethod(m))
              continue;
          }
          int score = methodApplicabilityScore_onTypes(m, argTypes);
          if (score < Integer.MAX_VALUE)
            best.put(m, score);
        }
      return best.get();
    } catch (Exception __e) {
      throw rethrow(__e);
    }
  }

  static public Method mostApplicableMethod_onTypes(Iterable<Method> methods, Class... argTypes) {
    Lowest<Method> best = new Lowest();
    if (methods != null)
      for (Method m : methods) {
        int score = methodApplicabilityScore_onTypes(m, argTypes);
        if (score < Integer.MAX_VALUE)
          best.put(m, score);
      }
    return best.get();
  }

  static public <A> List<A> filter(Iterable<A> c, Object pred) {
    if (pred instanceof F1)
      return filter(c, (F1<A, Boolean>) pred);
    List x = new ArrayList();
    if (c != null)
      for (Object o : c) if (isTrue(callF(pred, o)))
        x.add(o);
    return x;
  }

  static public List filter(Object pred, Iterable c) {
    return filter(c, pred);
  }

  static public <A, B extends A> List<B> filter(Iterable<B> c, F1<A, Boolean> pred) {
    List x = new ArrayList();
    if (c != null)
      for (B o : c) if (pred.get(o))
        x.add(o);
    return x;
  }

  static public <A, B extends A> List<B> filter(F1<A, Boolean> pred, Iterable<B> c) {
    return filter(c, pred);
  }

  static public <A, B extends A> List<B> filter(Iterable<B> c, IF1<A, Boolean> pred) {
    List x = new ArrayList();
    if (c != null)
      for (B o : c) if (pred.get(o))
        x.add(o);
    return x;
  }

  static public <A, B extends A> List<B> filter(B[] c, IF1<A, Boolean> pred) {
    List x = new ArrayList();
    if (c != null)
      for (B o : c) if (pred.get(o))
        x.add(o);
    return x;
  }

  static public <A, B extends A> List<B> filter(IF1<A, Boolean> pred, Iterable<B> c) {
    return filter(c, pred);
  }

  static public Map<Class, Method[]> nonDefaultInterfaceMethods_cache = newDangerousWeakHashMap();

  static public Method[] nonDefaultInterfaceMethods(Class c) {
    Method[] methods;
    synchronized (nonDefaultInterfaceMethods_cache) {
      methods = nonDefaultInterfaceMethods_cache.get(c);
      if (methods == null)
        nonDefaultInterfaceMethods_cache.put(c, methods = toTypedArray(Method.class, findNonDefaultInterfaceMethods(c)));
    }
    return methods;
  }

  static public <B, A extends B> A addAndReturn(Collection<B> c, A a) {
    if (c != null)
      c.add(a);
    return a;
  }

  static public <A> Value<A> value(A a) {
    return new Value<A>(a);
  }

  static public HashMap litmap(Object... x) {
    HashMap map = new HashMap();
    litmap_impl(map, x);
    return map;
  }

  static public void litmap_impl(Map map, Object... x) {
    if (x != null)
      for (int i = 0; i < x.length - 1; i += 2) if (x[i + 1] != null)
        map.put(x[i], x[i + 1]);
  }

  static public ThreadLocal<Long> saveTiming_last = new ThreadLocal();

  static public void saveTiming(long ms) {
    print(ms + " ms");
    saveTiming_noPrint(ms);
  }

  static public void saveTiming_noPrint(long ms) {
    saveTiming_last.set(ms);
  }

  static public ThreadLocal<Long> saveTiming_tl() {
    return saveTiming_last;
  }

  static public Object time(Object f) {
    long time = sysNow();
    Object o = callF(f);
    done2_always(str(f), time);
    return o;
  }

  static public <A> A time(F0<A> f) {
    return (A) time((Object) f);
  }

  static public <A> A time(IF0<A> f) {
    return (A) time((Object) f);
  }

  static public <A> A time(String msg, IF0<A> f) {
    long time = sysNow();
    A o = f.get();
    done2_always(msg, time);
    return o;
  }

  static public void time(Runnable f) {
    time(str(f), f);
  }

  static public void time(String msg, Runnable f) {
    time(msg, runnableToIF0(f));
  }

  static public DynamicObject dO(String className, Object... x) {
    return dynamicObject(className, x);
  }

  static public <A, B> B syncMapGetOrCreate(Map<A, B> map, A key, Class<? extends B> c) {
    return syncGetOrCreate(map, key, c);
  }

  static public <A, B> B syncMapGetOrCreate(Map<A, B> map, A key, Object f) {
    return syncGetOrCreate(map, key, f);
  }

  static public <A, B> B syncMapGetOrCreate(Class<? extends B> c, Map<A, B> map, A key) {
    return syncGetOrCreate(c, map, key);
  }

  static public <A, B> B syncMapGetOrCreate(Map<A, B> map, A key, IF0<B> f) {
    return syncGetOrCreate(map, key, f);
  }

  static public List<String> ciSorted(Collection<String> c) {
    return sortedIgnoreCase(c);
  }

  static public double nsToMicroseconds(double ns) {
    return nanosToMicroseconds(ns);
  }

  static public String microSymbol() {
    return "\u00B5";
  }

  static public <A> OKOrError<A> okOrError(IF0<A> f) {
    try {
      return OKOrError_ok(f.get());
    } catch (Throwable e) {
      printStackTrace(e);
      return OKOrError_error(e);
    }
  }

  static public <A> OKOrError<A> okOrError(Runnable r) {
    return okOrError(runnableToIF0(r));
  }

  static public String toStringWithClass(Object o) {
    return o == null ? null : className(o) + " - " + o;
  }

  static public String nlLogic_text(Exp e) {
    return e == null ? null : e.text();
  }

  static public String nlLogic_text(IfThen r) {
    return r == null ? null : r.text();
  }

  static public int syncL(Collection l) {
    if (l == null)
      return 0;
    synchronized (collectionMutex(l)) {
      return l.size();
    }
  }

  static public int syncL(Map map) {
    if (map == null)
      return 0;
    synchronized (collectionMutex(map)) {
      return map.size();
    }
  }

  static public <A> List<A> syncL() {
    return syncList();
  }

  static public ReliableSingleThread rst(Runnable r) {
    return new ReliableSingleThread(r);
  }

  static public Class _run(String progID, String... args) {
    Class main = hotwire(progID);
    callMain(main, args);
    return main;
  }

  static public <A extends Concept> Collection<A> conceptsWhere(Class<A> c, Object... params) {
    return findConceptsWhere(c, params);
  }

  static public Collection<Concept> conceptsWhere(String c, Object... params) {
    return findConceptsWhere(c, params);
  }

  static public <A extends Concept> Collection<A> conceptsWhere(Concepts concepts, Class<A> c, Object... params) {
    return findConceptsWhere(concepts, c, params);
  }

  static public <A> List<A> sortByCalculatedFieldAlphaNumIC(Iterable<A> c, IF1<A, String> f) {
    List<A> l = cloneList(c);
    sort(l, (a, b) -> cmpAlphanumIC(f.get(a), f.get(b)));
    return l;
  }

  static public AutoCloseable tempAddGlobalCtrlKeyListener(IVF1<Boolean> onStatusChanged) {
    AWTEventListener l = new AWTEventListener() {

      public Boolean status;

      public void eventDispatched(AWTEvent evt) {
        if (evt instanceof InputEvent) {
          Boolean b = ((InputEvent) evt).isControlDown();
          if (!eq(b, status))
            pcallF_typed(onStatusChanged, status = b);
        }
      }
    };
    Toolkit.getDefaultToolkit().addAWTEventListener(l, AWTEvent.KEY_EVENT_MASK | AWTEvent.MOUSE_EVENT_MASK | AWTEvent.MOUSE_MOTION_EVENT_MASK);
    return () -> Toolkit.getDefaultToolkit().removeAWTEventListener(l);
  }

  static public void sleepSeconds(double s) {
    if (s > 0)
      sleep(round(s * 1000));
  }

  static public int done_minPrint = 10;

  static public long done(long startTime, String desc) {
    long time = now() - startTime;
    if (time >= done_minPrint)
      print(desc + " [" + time + " ms]");
    return time;
  }

  static public long done(String desc, long startTime) {
    return done(startTime, desc);
  }

  static public long done(long startTime) {
    return done(startTime, "");
  }

  static public void close(AutoCloseable c) {
    _close(c);
  }

  static public <A extends JComponent> A setEnabled(A c, boolean enable) {
    if (c != null) {
      swing(() -> {
        c.setEnabled(enable);
      });
    }
    return c;
  }

  static public <A extends JComponent> A setEnabled(boolean enable, A c) {
    return setEnabled(c, enable);
  }

  static public void setEnabled(boolean enable, JComponent... l) {
    for (var c : unnullForIteration(l)) setEnabled(c, enable);
  }

  static public JWindow infoBox(Object text) {
    return infoMessage(strOrNull(text));
  }

  static public JWindow infoBox(String text) {
    return infoMessage(text);
  }

  static public JWindow infoBox(String text, double seconds) {
    return infoMessage(text, seconds);
  }

  static public JWindow infoBox(Throwable e) {
    return infoMessage(e);
  }

  static public String formatDouble1(double d) {
    return formatDouble(d, 1);
  }

  static public <A> A waitForVarPredicate(Var<A> v, IF0<Boolean> pred) {
    try {
      synchronized (v) {
        while (!pred.get()) v.wait();
        return v.get();
      }
    } catch (Exception __e) {
      throw rethrow(__e);
    }
  }

  static public SimpleLiveValue<String> stringLiveValue() {
    return new SimpleLiveValue(String.class);
  }

  static public SimpleLiveValue<String> stringLiveValue(String value) {
    return new SimpleLiveValue(String.class, value);
  }

  static public JPanel jline(final Component... components) {
    return swing(() -> {
      return new LeftAlignedLine(components);
    });
  }

  static public <A extends Component> JPanel jline(List<A> components) {
    return jline(asArray(Component.class, components));
  }

  static public String getText(final AbstractButton c) {
    return c == null ? "" : (String) swingAndWait(new F0<Object>() {

      public Object get() {
        try {
          return c.getText();
        } catch (Exception __e) {
          throw rethrow(__e);
        }
      }

      public String toString() {
        return "return c.getText();";
      }
    });
  }

  static public String getText(final JTextComponent c) {
    return c == null ? "" : (String) swingAndWait(new F0<Object>() {

      public Object get() {
        try {
          return c.getText();
        } catch (Exception __e) {
          throw rethrow(__e);
        }
      }

      public String toString() {
        return "return c.getText();";
      }
    });
  }

  static public String getText(final JLabel l) {
    return l == null ? "" : (String) swingAndWait(new F0<Object>() {

      public Object get() {
        try {
          return l.getText();
        } catch (Exception __e) {
          throw rethrow(__e);
        }
      }

      public String toString() {
        return "return l.getText();";
      }
    });
  }

  static public String getText(final JComboBox cb) {
    if (cb == null)
      return null;
    if (isEditableComboBox(cb))
      return unnull((String) cb.getEditor().getItem());
    else
      return str(cb.getSelectedItem());
  }

  static public int getCaretPosition(final JTextComponent c) {
    return c == null ? 0 : swing(new F0<Integer>() {

      public Integer get() {
        try {
          return c.getCaretPosition();
        } catch (Exception __e) {
          throw rethrow(__e);
        }
      }

      public String toString() {
        return "return c.getCaretPosition();";
      }
    });
  }

  static public <A extends JComponent> A onLeftClick(final A c, final Object runnable) {
    {
      swing(() -> {
        c.addMouseListener(leftClickMouseAdapter(runnable));
      });
    }
    return c;
  }

  static public TrayIcon onLeftClick(final TrayIcon c, final Object runnable) {
    {
      swing(() -> {
        c.addMouseListener(leftClickMouseAdapter_noPt(runnable));
      });
    }
    return c;
  }

  static public <A extends JComponent> A onLeftClick(final Object runnable, A c) {
    return onLeftClick(c, runnable);
  }

  static public <A extends JComponent> A onLeftClick(Runnable runnable, A c) {
    return onLeftClick((Object) runnable, c);
  }

  static public <A extends JComponent> A onLeftClick(A c, Runnable r) {
    return onLeftClick(r, c);
  }

  static public <A extends JComponent> A onLeftClick(A c, IVF1<Pt> r) {
    return onLeftClick(c, (Object) r);
  }

  static public void moveCaretToLineAndCol(JTextArea ta, LineAndColumn lac) {
    swing(() -> {
      try {
        setCaretPosition(ta, ta.getLineStartOffset(lac.line - 1) + lac.col - 1);
      } catch (Throwable __e) {
        printStackTrace(__e);
      }
    });
  }

  static public <A extends JComponent> A focus(final A a) {
    if (a != null)
      swingLater(new Runnable() {

        public void run() {
          try {
            a.requestFocus();
          } catch (Exception __e) {
            throw rethrow(__e);
          }
        }

        public String toString() {
          return "a.requestFocus();";
        }
      });
    return a;
  }

  static public Object swing(Object f) {
    return swingAndWait(f);
  }

  static public void swing(Runnable f) {
    swingAndWait(f);
  }

  static public <A> A swing(F0<A> f) {
    return (A) swingAndWait(f);
  }

  static public <A> A swing(IF0<A> f) {
    return (A) swingAndWait(f);
  }

  static public void addMenuItems(JMenu m, Object... x) {
    fillJMenu(m, x);
  }

  static public void addMenuItems(JPopupMenu m, Object... x) {
    fillJPopupMenu(m, x);
  }

  static public Runnable runnableThread(final Runnable r) {
    return new Runnable() {

      public void run() {
        try {
          startThread(r);
        } catch (Exception __e) {
          throw rethrow(__e);
        }
      }

      public String toString() {
        return "startThread(r)";
      }
    };
  }

  static public JTextArea showTextWordWrapped(final String title, final String text) {
    return showWrappedText(title, text);
  }

  static public JTextArea showTextWordWrapped(Object text) {
    return showWrappedText(text);
  }

  static public JPanel centerAndEastWithMargin(Swingable c, Swingable e) {
    return centerAndEastWithMargin(c, toComponent(e));
  }

  static public JPanel centerAndEastWithMargin(Swingable c, Component e) {
    return centerAndEastWithMargin(toComponent(c), e);
  }

  static public JPanel centerAndEastWithMargin(Component c, Swingable e) {
    return centerAndEastWithMargin(c, toComponent(e));
  }

  static public JPanel centerAndEastWithMargin(Component c, Component e) {
    return centerAndEastWithMarginInbetween(c, e);
  }

  static public JScrollPane jBorderlessHigherScrollPane(JComponent c) {
    return borderlessScrollPane(jHigherScrollPane(c));
  }

  static public JPanel jfullcenter(Component c) {
    return jFullCenter(c);
  }

  static public <A extends Component> A markVisualizer(Object visualizer, A a) {
    return setMetaSrc(a, visualizer);
  }

  static public <A extends JTextComponent> A bindTextComponentToLiveValue_bothWays_noInitialUndo(A tc, SimpleLiveValue<String> lv) {
    onFirstShow(tc, () -> clearTextComponentUndoList(tc));
    return bindTextComponentToLiveValue_bothWays(tc, lv);
  }

  static public <A extends JComponent> A onCtrlEnter(A c, Runnable action) {
    return onCtrlEnter(c, (Object) action);
  }

  static public <A extends JComponent> A onCtrlEnter(A c, Object action) {
    addKeyListener(c, ctrlEnterKeyListener(action));
    return c;
  }

  static public SingleThread awtCalcEvery(JFrame f, int delay, int firstDelay, final Object runnable) {
    return awtCalcRegularly(f, delay, firstDelay, runnable);
  }

  static public SingleThread awtCalcEvery(JComponent c, int delay, int firstDelay, final Object runnable) {
    return awtCalcRegularly(c, delay, firstDelay, runnable);
  }

  static public SingleThread awtCalcEvery(JFrame f, int delay, final Object runnable) {
    return awtCalcRegularly(f, delay, delay, runnable);
  }

  static public SingleThread awtCalcEvery(int delay, JComponent c, Runnable runnable) {
    return awtCalcRegularly(c, delay, delay, runnable);
  }

  static public SingleThread awtCalcEvery(JComponent c, int delay, Runnable runnable) {
    return awtCalcRegularly(c, delay, delay, runnable);
  }

  static public SingleThread awtCalcEvery(JComponent c, int delay, final Object runnable) {
    return awtCalcRegularly(c, delay, delay, runnable);
  }

  static public SingleThread awtCalcEvery(JComponent c, double delay, Runnable runnable) {
    return awtCalcEvery(c, delay, (Object) runnable);
  }

  static public SingleThread awtCalcEvery(JComponent c, double delay, Object runnable) {
    return awtCalcEvery(c, toMS_int(delay), runnable);
  }

  static public SingleThread awtCalcEvery(JComponent c, double firstDelay, double delay, final Object runnable) {
    return awtCalcEvery(c, toMS_int(delay), toMS_int(firstDelay), runnable);
  }

  static public AutoCompletion installCompletionProvider(DefaultCompletionProvider completionProvider, RSyntaxTextArea textArea) {
    return swing(() -> {
      if (completionProvider == null || textArea == null)
        return null;
      completionProvider.setAutoActivationRules(true, " ");
      var autoComplete = new AutoCompletion(completionProvider);
      autoComplete.setAutoCompleteSingleChoices(false);
      autoComplete.setAutoActivationEnabled(true);
      autoComplete.setAutoActivationDelay(2000);
      autoComplete.install(textArea);
      return autoComplete;
    });
  }

  static public JPanel jCenteredSection(Component c) {
    return jCenteredSection("", c);
  }

  static public JPanel jCenteredSection(String title, Swingable c) {
    return jCenteredSection(title, wrap(c));
  }

  static public JPanel jCenteredSection(String title, Component c) {
    return swing(new F0<JPanel>() {

      public JPanel get() {
        try {
          JPanel p = jSection(title, c);
          ((TitledBorder) p.getBorder()).setTitleJustification(TitledBorder.CENTER);
          return p;
        } catch (Exception __e) {
          throw rethrow(__e);
        }
      }

      public String toString() {
        return "JPanel p = jSection(title, c);\r\n    ((TitledBorder) p.getBorder()).setTitleJu...";
      }
    });
  }

  static public JPanel jCenteredSection(String title) {
    return jCenteredSection(title, jpanel());
  }

  static public JButton jbutton(String text, Runnable action) {
    return newButton(text, action);
  }

  static public JButton jbutton(String text, Object action) {
    return newButton(text, action);
  }

  static public JButton jbutton(String text) {
    return newButton(text, null);
  }

  static public JButton jbutton(Action action) {
    return swingNu(JButton.class, action);
  }

  static public JPanel withTopAndLeftMargin(Component c) {
    return withTopAndLeftMargin(defaultMargin(), c);
  }

  static public JPanel withTopAndLeftMargin(int w, Component c) {
    return swing(() -> {
      JPanel p = marginPanel();
      p.setBorder(BorderFactory.createEmptyBorder(w, w, 0, 0));
      p.add(c);
      return p;
    });
  }

  static public boolean isShowing(Component c) {
    return isComponentShowing(c);
  }

  static public void runInQAndWait(Q q, Runnable r) {
    if (r == null)
      return;
    if (isInQ(q)) {
      callF(r);
      return;
    }
    final Flag done = new Flag();
    final Var<Throwable> error = new Var();
    q.add(new Runnable() {

      public void run() {
        try {
          try {
            callF(r);
          } catch (Throwable e) {
            error.set(e);
          } finally {
            done.raise();
          }
        } catch (Exception __e) {
          throw rethrow(__e);
        }
      }

      public String toString() {
        return "try {\r\n      callF(r);\r\n    } catch (Throwable e) {\r\n      error.set(e);\r\n   ...";
      }
    });
    done.waitUntilUp();
    if (error.has())
      throw rethrow(error.get());
  }

  static public <A> RunResultWithTimestamps<A> runResultWithTimestamps(IF0<A> f) {
    return new RunResultWithTimestamps<A>().run(f);
  }

  static public int shorten_default = 100;

  static public String shorten(CharSequence s) {
    return shorten(s, shorten_default);
  }

  static public String shorten(CharSequence s, int max) {
    return shorten(s, max, "...");
  }

  static public String shorten(CharSequence s, int max, String shortener) {
    if (s == null)
      return "";
    if (max < 0)
      return str(s);
    return s.length() <= max ? str(s) : subCharSequence(s, 0, min(s.length(), max - l(shortener))) + shortener;
  }

  static public String shorten(int max, CharSequence s) {
    return shorten(s, max);
  }

  static public String exceptionToStringShorter_dontDropOuterExceptions(Throwable e) {
    String msg = hideCredentials(unnull(e.getMessage()));
    String className = baseClassName(e);
    if (!eq(className, "RuntimeException") && (msg.indexOf("Error") < 0 && msg.indexOf("Exception") < 0))
      return className + prependIfNempty(": ", msg);
    else
      return msg;
  }

  static public JComponent jErrorView(Throwable e) {
    return jSmallErrorView(e);
  }

  static public String exceptionToStringShorter(Throwable e) {
    e = getInnerException(e);
    return exceptionToStringShorter_dontDropOuterExceptions(e);
  }

  static public JTextArea showText(final String title, Object text) {
    return showText(null, title, text);
  }

  static public JTextArea showText(JTextArea ta, final String title, Object text) {
    final String _text = str(text);
    if (ta != null)
      return activateFrameAndReturnComponent(setFrameTitle(title, setText(ta, _text)));
    return swing(new F0<JTextArea>() {

      public JTextArea get() {
        try {
          JTextArea textArea = newTypeWriterTextArea(_text);
          makeFrame(title, new JScrollPane(textArea));
          return textArea;
        } catch (Exception __e) {
          throw rethrow(__e);
        }
      }

      public String toString() {
        return "JTextArea textArea = newTypeWriterTextArea(_text);\r\n    makeFrame(title, new ...";
      }
    });
  }

  static public JTextArea showText(Object text) {
    return showText(str(text));
  }

  static public JTextArea showText(String text) {
    return showText(autoFrameTitle(), text);
  }

  static public JTextArea showText() {
    return showText("");
  }

  static public <A> String pnlToString(String prefix, Iterable<A> l) {
    return hijackPrint(new Runnable() {

      public void run() {
        try {
          pnl(prefix, l);
        } catch (Exception __e) {
          throw rethrow(__e);
        }
      }

      public String toString() {
        return "pnl(prefix, l)";
      }
    });
  }

  static public <A> String pnlToString(final Iterable<A> l) {
    return hijackPrint(new Runnable() {

      public void run() {
        try {
          pnl(l);
        } catch (Exception __e) {
          throw rethrow(__e);
        }
      }

      public String toString() {
        return "pnl(l)";
      }
    });
  }

  static public <A> String pnlToString(final A[] l) {
    return hijackPrint(new Runnable() {

      public void run() {
        try {
          pnl(l);
        } catch (Exception __e) {
          throw rethrow(__e);
        }
      }

      public String toString() {
        return "pnl(l)";
      }
    });
  }

  static public <A, B> String pnlToString(final Map<A, B> map) {
    return hijackPrint(new Runnable() {

      public void run() {
        try {
          pnl(map);
        } catch (Exception __e) {
          throw rethrow(__e);
        }
      }

      public String toString() {
        return "pnl(map)";
      }
    });
  }

  static public <A, B> String pnlToString(MultiMap<A, B> map) {
    return pnlToString(multiMapToMap(map));
  }

  static public <B> TreeMap<String, B> toCIMap(Map<String, B> map) {
    return asCIMap(map);
  }

  static public <A extends JTextComponent> A setEditable(A a, boolean b) {
    if (a != null) {
      swing(() -> {
        a.setEditable(b);
      });
    }
    return a;
  }

  static public String strOrNull(Object o) {
    return o == null ? null : str(o);
  }

  static public AtomicLong randomClassName_counter = new AtomicLong();

  static public String randomClassName() {
    return "UserCode" + inc(randomClassName_counter);
  }

  static public <A> A print_tabToSingleSpace(A o) {
    print(tabToSingleSpace(str(o)));
    return o;
  }

  static public Object load(String varName) {
    readLocally(varName);
    return get(mc(), varName);
  }

  static public Object load(String progID, String varName) {
    readLocally(progID, varName);
    return get(mc(), varName);
  }

  static public ClassLoader myClassLoader() {
    return _getClass(mc()).getClassLoader();
  }

  static public <A> A newInstance(Class<A> c, Object... args) {
    return nuObject(c, args);
  }

  static public Object newInstance(String className, Object... args) {
    return nuObject(className, args);
  }

  static public WatchEvent.Kind[] jdk_watchService_allEventKinds() {
    return new WatchEvent.Kind[] { ENTRY_CREATE, ENTRY_DELETE, ENTRY_MODIFY, OVERFLOW };
  }

  static public <A> Set<A> synchroSet() {
    return synchroHashSet();
  }

  static public <A> Set<A> synchroSet(Set<A> set) {
    return Collections.synchronizedSet(set);
  }

  static public String exceptionToStringShort(Throwable e) {
    lastException(e);
    e = getInnerException(e);
    String msg = hideCredentials(unnull(e.getMessage()));
    if (msg.indexOf("Error") < 0 && msg.indexOf("Exception") < 0)
      return baseClassName(e) + prependIfNempty(": ", msg);
    else
      return msg;
  }

  static public List<File> findAllDirs(File dir) {
    List<File> out = new ArrayList();
    findAllDirs(dir, out);
    return out;
  }

  static public void findAllDirs(File dir, List<File> out) {
    out.add(dir);
    try {
      for (File f : listFiles(dir)) if (f.isDirectory())
        findAllDirs(f, out);
    } catch (Throwable __e) {
      print(exceptionToStringShort(__e));
    }
  }

  static volatile public boolean sleep_noSleep = false;

  static public void sleep(long ms) {
    ping();
    if (ms < 0)
      return;
    if (isAWTThread() && ms > 100)
      throw fail("Should not sleep on AWT thread");
    try {
      Thread.sleep(ms);
    } catch (Exception e) {
      throw new RuntimeException(e);
    }
  }

  static public void sleep() {
    try {
      if (sleep_noSleep)
        throw fail("nosleep");
      print("Sleeping.");
      sleepQuietly();
    } catch (Exception __e) {
      throw rethrow(__e);
    }
  }

  static public <A> IterableIterator<A> reversedIterator(final List<A> l) {
    return new IterableIterator<A>() {

      public int i = l(l) - 1;

      public boolean hasNext() {
        return i >= 0;
      }

      public A next() {
        return l.get(i--);
      }
    };
  }

  static public RuntimeException error() {
    throw new RuntimeException("fail");
  }

  static public RuntimeException error(String msg) {
    throw new RuntimeException(msg);
  }

  static public String ok(Object o) {
    return format("ok *", o);
  }

  static public LineAndColumn parseLineAndColumn(String s) {
    String re = "\\bLine (" + regexpN2() + "), col (" + regexpN2() + ")";
    List<String> l = regexpLastGroupsIC(re, s);
    return l == null ? null : new LineAndColumn(parseIntN2(first(l)), parseIntN2(second(l)));
  }

  static public String localDateWithSeconds(long time) {
    SimpleDateFormat format = simpleDateFormat_local("yyyy/MM/dd HH:mm:ss");
    return format.format(time);
  }

  static public String localDateWithSeconds() {
    return localDateWithSeconds(now());
  }

  static public double elapsedMinutes_timestamp(long time) {
    return toMinutes(now() - time);
  }

  static public double elapsedSeconds_timestamp(long time) {
    return toSeconds(now() - time);
  }

  static public SingleComponentPanel singleComponentPanel() {
    return singleComponentPanel(null);
  }

  static public SingleComponentPanel singleComponentPanel(final Component c) {
    return swing(new F0<SingleComponentPanel>() {

      public SingleComponentPanel get() {
        try {
          return new SingleComponentPanel(c);
        } catch (Exception __e) {
          throw rethrow(__e);
        }
      }

      public String toString() {
        return "return new SingleComponentPanel(c);";
      }
    });
  }

  static public JPanel jpanel(LayoutManager layout, Object... components) {
    return jpanel(layout, asList(components));
  }

  static public JPanel jpanel(LayoutManager layout, List components) {
    return smartAdd(jpanel(layout), components);
  }

  static public JPanel jpanel(LayoutManager layout) {
    return swing(() -> new JPanel(layout));
  }

  static public JPanel jpanel() {
    return swing(() -> new JPanel());
  }

  static public JPanel westAndCenterWithMargin(Component w, Component c) {
    return westAndCenter(withRightMargin(w), c);
  }

  static public JPanel westAndCenterWithMargin(int margin, Component w, Component c) {
    return westAndCenter(withRightMargin(margin, w), c);
  }

  static public JPanel vstack(Object... parts) {
    return vstack2(parts);
  }

  static public JPanel vstack(List parts) {
    return vstack(toObjectArray(parts));
  }

  static public JLabel jClickableImage_instantToolTip(String imageID, String toolTip, Runnable action) {
    return onLeftClick(instaToolTip(toolTip, jImageLabel(imageID)), action);
  }

  static public String collapse(String s) {
    return collapseWord(s);
  }

  static public JPanel northAndCenterWithMargin(int margin, Component n, Component c) {
    return northAndCenter(withBottomMargin(margin, n), c);
  }

  static public JPanel northAndCenterWithMargin(Component n, Component c) {
    return northAndCenter(withBottomMargin(n), c);
  }

  static public JLabel liveValueLabel(LiveValue lv) {
    return jLiveValueLabel(lv);
  }

  static public JLabel liveValueLabel(IVarWithNotify<?> var) {
    return jVarLabel(var);
  }

  static public JSplitPane jhsplit(Component l, Component r) {
    return jhsplit(l, r, 0.5);
  }

  static public JSplitPane jhsplit(Component l, Component r, double splitPoint, int delay) {
    return jhsplit(l, r, splitPoint);
  }

  static public JSplitPane jhsplit(Component l, Component r, double splitPoint) {
    return setSplitPaneOnFirstShowing(swingNu(JSplitPane.class, JSplitPane.HORIZONTAL_SPLIT, wrap(l), wrap(r)), splitPoint);
  }

  static public JSplitPane jhsplit(double splitPoint, Component l, Component r) {
    return jhsplit(l, r, splitPoint);
  }

  static public <A> A replaceIfEqual(A a, A b, A c) {
    return eq(a, b) ? c : a;
  }

  static public String replaceRegexp(String s, String pat, IF1<Matcher, String> f) {
    return regexpReplace(s, pat, f);
  }

  static public String replaceRegexp(String s, String pat, String replacement) {
    return regexpReplace(s, pat, replacement);
  }

  static public <A> void setLast(List<A> l, A a) {
    replaceLastElement(l, a);
  }

  static public String concatMapStrings(Object f, Iterable l) {
    return concatMap_strings(f, l);
  }

  static public String concatMapStrings(Object f, Object[] l) {
    return concatMap_strings(f, l);
  }

  static public String concatMapStrings(Iterable l, Object f) {
    return concatMap_strings(l, f);
  }

  static public <A> String concatMapStrings(Iterable<A> l, IF1<A, String> f) {
    return concatMap_strings(l, f);
  }

  static public <A> String concatMapStrings(IF1<A, String> f, Iterable<A> l) {
    return concatMap_strings(f, l);
  }

  static public <A> String concatMapStrings(IF1<A, String> f, A[] l) {
    return concatMap_strings(f, l);
  }

  static public String curly(String s) {
    return optionalCurlyBrace(s);
  }

  static public String appendNewLineIfNempty(String s) {
    return empty(s) ? "" : s + "\n";
  }

  static public String joinNemptiesWithEmptyLines(List<String> l) {
    return joinWithEmptyLines(nempties(l));
  }

  static public String joinNemptiesWithEmptyLines(String... l) {
    return joinNemptiesWithEmptyLines(asList(l));
  }

  static public String lines_rtrim(Collection lines) {
    return rtrim_fromLines(lines);
  }

  static public String toJava(Object o) {
    return str(new ToJava().get(o));
  }

  static public List<Integer> countIteratorToList_incl(int b) {
    return countIteratorToList_incl(0, b);
  }

  static public List<Integer> countIteratorToList_incl(int a, int b) {
    return countIteratorToList_inclusive(a, b);
  }

  static public <A> List<A> countIteratorToList_incl(int b, IF1<Integer, A> f) {
    return countIteratorToList_incl(0, b, f);
  }

  static public <A> List<A> countIteratorToList_incl(int a, int b, IF1<Integer, A> f) {
    return countIteratorToList_inclusive(a, b, f);
  }

  static public List<Integer> countIteratorToList_incl(int a, int b, int step) {
    return countIteratorToList_inclusive(a, b, step);
  }

  static public <A> List<A> countIteratorToList_incl(double a, double b, double step, IF1<Double, A> f) {
    return countIteratorToList_inclusive(a, b, step, f);
  }

  static public <A> List<Double> countIteratorToList_incl(double a, double b, double step) {
    return countIteratorToList_inclusive(a, b, step);
  }

  static public <A> List<A> countIteratorToList_incl(IF1<Double, A> f, double a, double b, double step) {
    return countIteratorToList_inclusive(f, a, b, step);
  }

  static public <A> List<A> countIteratorToList_incl(IF1<Integer, A> f, int a, int b) {
    return countIteratorToList_incl(f, a, b, 1);
  }

  static public <A> List<A> countIteratorToList_incl(IF1<Integer, A> f, int a, int b, int step) {
    return countIteratorToList_inclusive(f, a, b, step);
  }

  static public List<String> allToString(Iterable c) {
    List<String> l = new ArrayList();
    for (Object o : unnull(c)) l.add(str(o));
    return l;
  }

  static public List<String> allToString(Object[] c) {
    List<String> l = new ArrayList();
    for (Object o : unnull(c)) l.add(str(o));
    return l;
  }

  static public String roundBracketed(String s) {
    return roundBracket(s);
  }

  static public String lambdaArgsToString_pureJava(String[] args) {
    return l(args) == 1 ? first(args) : roundBracketed(joinWithComma(args));
  }

  static public String lambdaArgsToString_pureJava(List<String> args) {
    return lambdaArgsToString_pureJava(toStringArray(args));
  }

  static public String joinNemptiesWithSpace(String... strings) {
    return joinNempties(" ", strings);
  }

  static public String joinNemptiesWithSpace(Collection<String> strings) {
    return joinNempties(" ", strings);
  }

  static public String strOrEmpty(Object o) {
    return o == null ? "" : str(o);
  }

  static public BufferedImage loadImage2(String snippetIDOrURL) {
    return loadBufferedImage(snippetIDOrURL);
  }

  static public BufferedImage loadImage2(File file) {
    return loadBufferedImage(file);
  }

  static public String unicode_downPointingTriangle() {
    return charToString(0x25BC);
  }

  static public void addActionListener(JTextField tf, final Runnable action) {
    onEnter(tf, action);
  }

  static public void addActionListener(final JComboBox cb, final Runnable action) {
    if (cb != null) {
      swing(() -> {
        cb.addActionListener(actionListener(action));
      });
    }
  }

  static public void addActionListener(final AbstractButton b, final Runnable action) {
    if (b != null) {
      swing(() -> {
        b.addActionListener(actionListener(action));
      });
    }
  }

  static public int getWidth(Component c) {
    return c == null ? 0 : (int) swingCall(c, "getWidth");
  }

  static public int getPreferredWidth(Component c) {
    return preferredWidth(c);
  }

  static public int getHeight(Component c) {
    return c == null ? 0 : (int) swingCall(c, "getHeight");
  }

  static public Map<Integer, Integer> rsyntaxTextArea_fixNumPad_map = litmap(KeyEvent.VK_UP, KeyEvent.VK_KP_UP, KeyEvent.VK_DOWN, KeyEvent.VK_KP_DOWN, KeyEvent.VK_LEFT, KeyEvent.VK_KP_LEFT, KeyEvent.VK_RIGHT, KeyEvent.VK_KP_RIGHT);

  static public boolean rsyntaxTextArea_fixNumPad_done = false;

  static public void rsyntaxTextArea_fixNumPad() {
    if (rsyntaxTextArea_fixNumPad_done)
      return;
    RSyntaxTextAreaDefaultInputMap inputMap = new RSyntaxTextAreaDefaultInputMap();
    for (KeyStroke key : inputMap.keys()) {
      Integer code = rsyntaxTextArea_fixNumPad_map.get(key.getKeyCode());
      if (code != null)
        inputMap.put(KeyStroke.getKeyStroke(code, key.getModifiers()), inputMap.get(key));
    }
    UIManager.put("RSyntaxTextAreaUI.inputMap", inputMap);
  }

  static public RSyntaxTextArea javaxSyntaxTextArea() {
    return swing(new F0<RSyntaxTextArea>() {

      public RSyntaxTextArea get() {
        try {
          RSyntaxTextArea textArea = new RSyntaxTextArea(1, 10);
          initSyntaxTextArea(textArea);
          textArea.setSyntaxEditingStyle(SyntaxConstants.SYNTAX_STYLE_JAVA);
          return textArea;
        } catch (Exception __e) {
          throw rethrow(__e);
        }
      }

      public String toString() {
        return "RSyntaxTextArea textArea = new RSyntaxTextArea(1, 10);\r\n    initSyntaxTextAre...";
      }
    });
  }

  static public List<JMenu> getMenus(JMenuBar mb) {
    if (mb == null)
      return null;
    return countIteratorAsList(mb.getMenuCount(), i -> mb.getMenu(i));
  }

  static public List<JMenuItem> getMenuItems(JMenu menu) {
    if (menu == null)
      return null;
    return nonNulls(countIterator(menu.getItemCount(), i -> menu.getItem(i)));
  }

  static public void showDialogOnSameScreen(JDialog dialog, Component c) {
    swing(() -> {
      if (dialog == null)
        return;
      Window w = getWindow(c);
      if (w != null)
        centerWindowWithin(dialog, screenBounds_safe(screenNrOfWindow(w)));
      dialog.setVisible(true);
    });
  }

  static public Font deriveFont(Font font, float size) {
    return font == null ? null : font.deriveFont(size);
  }

  static public String hijackPrint_tee(Runnable r) {
    final StringBuilder buf = new StringBuilder();
    Object old = interceptPrintInThisThread(new F1<String, Boolean>() {

      public Boolean get(String s) {
        buf.append(s);
        return true;
      }
    });
    try {
      callF(r);
      return str(buf);
    } finally {
      interceptPrintInThisThread(old);
    }
  }

  static public <A> List<A> syncGetAndClear(Collection<A> l) {
    return syncCloneAndClearList(l);
  }

  static public <A> A getWeakRef(Reference<A> ref) {
    return ref == null ? null : ref.get();
  }

  static public Object pcallF(Object f, Object... args) {
    return pcallFunction(f, args);
  }

  static public <A> A pcallF(F0<A> f) {
    try {
      return f == null ? null : f.get();
    } catch (Throwable __e) {
      printStackTrace(__e);
    }
    return null;
  }

  static public <A, B> B pcallF(F1<A, B> f, A a) {
    try {
      return f == null ? null : f.get(a);
    } catch (Throwable __e) {
      printStackTrace(__e);
    }
    return null;
  }

  static public <A> void pcallF(VF1<A> f, A a) {
    try {
      {
        if (f != null)
          f.get(a);
      }
    } catch (Throwable __e) {
      printStackTrace(__e);
    }
  }

  static public Object pcallF(Runnable r) {
    try {
      {
        if (r != null)
          r.run();
      }
    } catch (Throwable __e) {
      printStackTrace(__e);
    }
    return null;
  }

  static public <A> A pcallF(IF0<A> f) {
    try {
      return f == null ? null : f.get();
    } catch (Throwable __e) {
      printStackTrace(__e);
    }
    return null;
  }

  static public <A, B> B pcallF(IF1<A, B> f, A a) {
    try {
      return f == null ? null : f.get(a);
    } catch (Throwable __e) {
      printStackTrace(__e);
    }
    return null;
  }

  static public void cancelAndInterruptThread(Thread t) {
    if (t == null)
      return;
    cancelThread(t);
    t.interrupt();
  }

  static public long sysNow() {
    ping();
    return System.nanoTime() / 1000000;
  }

  static public java.util.Timer doLater_daemon(long delay, final Object r) {
    final java.util.Timer timer = new java.util.Timer(true);
    timer.schedule(timerTask(r, timer), delay);
    return timer;
  }

  static public java.util.Timer doLater_daemon(double delaySeconds, final Object r) {
    return doLater_daemon(toMS(delaySeconds), r);
  }

  static public void cancelTimer(javax.swing.Timer timer) {
    if (timer != null)
      timer.stop();
  }

  static public void cancelTimer(java.util.Timer timer) {
    if (timer != null)
      timer.cancel();
  }

  static public void cancelTimer(Object o) {
    if (o instanceof java.util.Timer)
      cancelTimer((java.util.Timer) o);
    else if (o instanceof javax.swing.Timer)
      cancelTimer((javax.swing.Timer) o);
    else if (o instanceof AutoCloseable) {
      try {
        ((AutoCloseable) o).close();
      } catch (Throwable __e) {
        printStackTrace(__e);
      }
    }
  }

  static public Pt toPt(Point p) {
    return p == null ? null : new Pt(p.x, p.y);
  }

  static public Pt toPt(Dimension d) {
    return d == null ? null : new Pt(d.width, d.width);
  }

  static public CharInToken charIndexToCharInToken(List<String> tok, int charIndex) {
    int i = 0, idx = 0, lTok;
    while (i < l(tok) && idx + (lTok = l(tok.get(i))) <= charIndex) {
      idx += lTok;
      i++;
    }
    return new CharInToken(tok, i, charIndex - idx);
  }

  static public boolean even(int i) {
    return (i & 1) == 0;
  }

  static public boolean even(long i) {
    return (i & 1) == 0;
  }

  static public boolean even(BigInteger n) {
    return even(n.intValue());
  }

  static public <A> List<A> takeFirst(List<A> l, int n) {
    return l(l) <= n ? l : newSubListOrSame(l, 0, n);
  }

  static public <A> List<A> takeFirst(int n, List<A> l) {
    return takeFirst(l, n);
  }

  static public String takeFirst(int n, String s) {
    return substring(s, 0, n);
  }

  static public String takeFirst(String s, int n) {
    return substring(s, 0, n);
  }

  static public CharSequence takeFirst(int n, CharSequence s) {
    return subCharSequence(s, 0, n);
  }

  static public <A> List<A> takeFirst(int n, Iterator<A> it) {
    if (it == null)
      return null;
    List l = new ArrayList();
    for (int _repeat_0 = 0; _repeat_0 < n; _repeat_0++) {
      if (it.hasNext())
        l.add(it.next());
      else
        break;
    }
    return l;
  }

  static public <A> List<A> takeFirst(int n, Iterable<A> i) {
    if (i == null)
      return null;
    return i == null ? null : takeFirst(n, i.iterator());
  }

  static public <A> List<A> takeFirst(int n, IterableIterator<A> i) {
    return takeFirst(n, (Iterator<A>) i);
  }

  static public int[] takeFirst(int n, int[] a) {
    return takeFirstOfIntArray(n, a);
  }

  static public short[] takeFirst(int n, short[] a) {
    return takeFirstOfShortArray(n, a);
  }

  static public byte[] takeFirst(int n, byte[] a) {
    return takeFirstOfByteArray(n, a);
  }

  static public byte[] takeFirst(byte[] a, int n) {
    return takeFirstOfByteArray(n, a);
  }

  static public double[] takeFirst(int n, double[] a) {
    return takeFirstOfDoubleArray(n, a);
  }

  static public double[] takeFirst(double[] a, int n) {
    return takeFirstOfDoubleArray(n, a);
  }

  static public <A, B> List<A> cloneKeys(Map<A, B> map) {
    return cloneList(keys(map));
  }

  static public List<String> stringsSortedByLength(Iterable<String> l) {
    return sortedByCalculatedField(l, new F1<String, Integer>() {

      public Integer get(String s) {
        try {
          return l(s);
        } catch (Exception __e) {
          throw rethrow(__e);
        }
      }

      public String toString() {
        return "l(s)";
      }
    });
  }

  static public <A, B> B floorValue(NavigableMap<A, B> map, A key) {
    if (map == null)
      return null;
    var e = map.floorEntry(key);
    return e == null ? null : e.getValue();
  }

  static public List concatMap(Object f, Iterable l) {
    return concatLists(map(f, l));
  }

  static public List concatMap(Iterable l, Object f) {
    return concatMap(f, l);
  }

  static public List concatMap(Object f, Object[] l) {
    return concatLists(map(f, l));
  }

  static public List concatMap(Object[] l, Object f) {
    return concatMap(f, l);
  }

  static public <A, B, C extends Iterable<B>> List<B> concatMap(Iterable<A> l, IF1<A, C> f) {
    return concatMap(l, (Object) f);
  }

  static public <A, B, C extends Iterable<B>> List<B> concatMap(IF1<A, C> f, Iterable<A> l) {
    return concatMap(l, f);
  }

  static public <A, B, C extends Iterable<B>> List<B> concatMap(IF1<A, C> f, A[] l) {
    return concatMap((Object) f, l);
  }

  static public List<String> methodNames(Object o) {
    return allMethodNames(o);
  }

  static public int lineNrToCharIndex(String s, int lineNr) {
    int i = 0;
    while (--lineNr > 0) i = smartIndexOf(s, '\n', i) + 1;
    return i;
  }

  static public int lengthOfLine(String text, int lineNr) {
    return l(getFromIterator(linesIterator(text), lineNr));
  }

  static public boolean stdEq2(Object a, Object b) {
    if (a == null)
      return b == null;
    if (b == null)
      return false;
    if (a.getClass() != b.getClass())
      return false;
    for (String field : allFields(a)) if (neq(getOpt(a, field), getOpt(b, field)))
      return false;
    return true;
  }

  static public int stdHash2(Object a) {
    if (a == null)
      return 0;
    return stdHash(a, toStringArray(allFields(a)));
  }

  static public String n(long l, String name) {
    return l + " " + trim(l == 1 ? singular(name) : getPlural(name));
  }

  static public String n(Collection l, String name) {
    return n(l(l), name);
  }

  static public String n(Map m, String name) {
    return n(l(m), name);
  }

  static public String n(Object[] a, String name) {
    return n(l(a), name);
  }

  static public String n(MultiSet ms, String name) {
    return n(l(ms), name);
  }

  static public double doubleRatio(double x, double y) {
    return y == 0 ? 0 : x / y;
  }

  static public double doubleRatio(Seconds x, Seconds y) {
    return doubleRatio(x.get(), y.get());
  }

  static public <A> Set<A> identityHashSet() {
    return Collections.newSetFromMap(new IdentityHashMap());
  }

  static public long nanos() {
    return nanoTime();
  }

  static public String n2OrStrOrNull(Object o) {
    if (o == null)
      return null;
    if (o instanceof Number)
      return n2(((Number) o).longValue());
    return str(o);
  }

  static public String formatElapsedTimeWithAppropriateUnit(double seconds) {
    if (seconds >= 1)
      return formatDouble(seconds, 3) + " s";
    double ms = seconds * 1000;
    if (ms >= 1)
      return formatDouble(ms, 3) + " ms";
    double us = ms * 1000;
    if (us >= 1)
      return formatDouble(us, 3) + " µs";
    double ns = us * 1000;
    return formatDouble(ns, 3) + " ns";
  }

  static public double nanosToSeconds(double nanos) {
    return nanoSecondsToSeconds(nanos);
  }

  static public JPanel northAndCenterWithMargins(Component n, Component c) {
    return applyDefaultMargin(northAndCenter(withBottomMargin(n), c));
  }

  static public JPanel northAndCenterWithMargins(int margin, Component n, Component c) {
    return applyMargin(margin, northAndCenter(withBottomMargin(margin, n), c));
  }

  static public JPanel westAndEastWithMargin(Component w, Component e) {
    JPanel panel = new JPanel(new BorderLayout());
    panel.add(BorderLayout.WEST, wrap(w));
    panel.add(BorderLayout.CENTER, horizontalStrut(10));
    panel.add(BorderLayout.EAST, wrap(e));
    return panel;
  }

  static public JComponent withLabel(String label, JComponent component) {
    return westAndCenter(jlabel(label + " "), component);
  }

  static public JComponent withLabel(JComponent label, JComponent component) {
    return westAndCenterWithMargin(label, component);
  }

  static public JLabel jlabel(final String text) {
    return swingConstruct(BetterLabel.class, text);
  }

  static public JLabel jlabel() {
    return jlabel(" ");
  }

  static public <A extends JComponent> A fontSizePlus(final int delta, final A c) {
    if (c != null) {
      swing(() -> {
        Font font = c.getFont();
        c.setFont(font.deriveFont(font.getSize2D() + delta));
      });
    }
    return c;
  }

  static public Container getParent(final Component c) {
    return c == null ? null : swing(new F0<Container>() {

      public Container get() {
        try {
          return c.getParent();
        } catch (Exception __e) {
          throw rethrow(__e);
        }
      }

      public String toString() {
        return "return c.getParent();";
      }
    });
  }

  static public long toLong(Object o) {
    if (o instanceof Number)
      return ((Number) o).longValue();
    if (o instanceof String)
      return parseLong((String) o);
    return 0;
  }

  static public JLabel jcenteredLabel(String text) {
    return setHorizontalAlignment(JLabel.CENTER, jLabel(text));
  }

  static public JLabel jcenteredLabel() {
    return jcenteredLabel(" ");
  }

  static public JLabel jcenterNarrowLabel() {
    return jcenterNarrowLabel(50);
  }

  static public JLabel jcenterNarrowLabel(int width) {
    return jcenterNarrowLabel(width, "");
  }

  static public JLabel jcenterNarrowLabel(String text) {
    return jcenterNarrowLabel(50, text);
  }

  static public JLabel jcenterNarrowLabel(int width, String text) {
    return centerLabel(jnarrowLabel(width, text));
  }

  static public JPanel jcenteredline(final Component... components) {
    return swing(new F0<JPanel>() {

      public JPanel get() {
        try {
          return jFullCenter(hstackWithSpacing(components));
        } catch (Exception __e) {
          throw rethrow(__e);
        }
      }

      public String toString() {
        return "return jFullCenter(hstackWithSpacing(components));";
      }
    });
  }

  static public JPanel jcenteredline(List<? extends Component> components) {
    return jcenteredline(asArray(Component.class, components));
  }

  static public int vstackWithSpacing_default = 10;

  static public JPanel vstackWithSpacing(final List parts) {
    return vstackWithSpacing(parts, vstackWithSpacing_default);
  }

  static public JPanel vstackWithSpacing(final List parts, final int spacing) {
    return swing(new F0<JPanel>() {

      public JPanel get() {
        try {
          JPanel panel = new JPanel(new GridBagLayout());
          GridBagConstraints gbc = new GridBagConstraints();
          gbc.weightx = 1;
          gbc.fill = GridBagConstraints.HORIZONTAL;
          gbc.gridwidth = GridBagConstraints.REMAINDER;
          gbc.insets = new Insets(spacing / 2, 0, (spacing + 1) / 2, 0);
          smartAddWithLayout(panel, gbc, toObjectArray(nonNulls(parts)));
          gbc.weighty = 1;
          gbc.insets = new Insets(0, 0, 0, 0);
          panel.add(jrigid(), gbc);
          return panel;
        } catch (Exception __e) {
          throw rethrow(__e);
        }
      }

      public String toString() {
        return "JPanel panel = new JPanel(new GridBagLayout);\r\n    new GridBagConstraints gbc...";
      }
    });
  }

  static public JPanel vstackWithSpacing(Component... parts) {
    return vstackWithSpacing(asList(parts), vstackWithSpacing_default);
  }

  static public JPanel vstackWithSpacing(int spacing, Component... parts) {
    return vstackWithSpacing(asList(parts), spacing);
  }

  static public JScrollPane jscroll_centered_borderless(Component c) {
    return borderlessScrollPane(jscroll_centered(c));
  }

  static public <A, B> List<Pair<A, List<B>>> multiMapToMapPairs(MultiMap<A, B> mm) {
    List<Pair<A, List<B>>> out = new ArrayList();
    for (A key : keys(mm)) out.add(pair(key, mm.get(key)));
    return out;
  }

  static public <A, B> List<Pair<A, Collection<B>>> multiMapToMapPairs(IMultiMap<A, B> mm) {
    List<Pair<A, Collection<B>>> out = new ArrayList();
    for (A key : keys(mm)) out.add(pair(key, mm.get(key)));
    return out;
  }

  static public <A, B> List<Pair<A, Set<B>>> multiSetMapToMapPairs(MultiSetMap<A, B> mm) {
    List<Pair<A, Set<B>>> out = new ArrayList();
    for (A key : keys(mm)) out.add(pair(key, mm.get(key)));
    return out;
  }

  static public <A, B> List<Pair<A, B>> mapToPairs(Map<A, B> map) {
    List<Pair<A, B>> l = emptyList(l(map));
    if (map != null)
      for (Map.Entry<A, B> e : map.entrySet()) l.add(pair(e.getKey(), e.getValue()));
    return l;
  }

  static public <A> List<A> cloneTakeFirst(Collection<A> l, int n) {
    n = min(n, l(l));
    List<A> out = emptyList(n);
    if (n != 0)
      for (A a : l) {
        out.add(a);
        if (l(out) >= n)
          break;
      }
    return out;
  }

  static public <A> List<A> cloneTakeFirst(int n, Collection<A> l) {
    return cloneTakeFirst(l, n);
  }

  static public <A> List<A> cloneTakeFirst(List<A> l, int n) {
    return l(l) <= n ? l : cloneSubList(l, 0, n);
  }

  static public <A> List<A> cloneTakeFirst(int n, List<A> l) {
    return cloneTakeFirst(l, n);
  }

  static public int hstackWithSpacing_spacing = 10;

  static public JPanel hstackWithSpacing(Object... parts) {
    parts = flattenArray2(parts);
    int spacing = hstackWithSpacing_spacing;
    int i = 0;
    if (first(parts) instanceof Integer) {
      spacing = toInt(first(parts));
      ++i;
    }
    JPanel panel = new JPanel(new GridBagLayout());
    GridBagConstraints gbc = new GridBagConstraints();
    gbc.weighty = 1;
    gbc.fill = GridBagConstraints.VERTICAL;
    gbc.gridheight = GridBagConstraints.REMAINDER;
    for (; i < l(parts); i++) {
      if (i != 0)
        panel.add(javax.swing.Box.createRigidArea(new Dimension(spacing, 0)), gbc);
      panel.add(wrapForSmartAdd(parts[i]), gbc);
    }
    gbc.weightx = 1;
    panel.add(jrigid(), gbc);
    return panel;
  }

  static public boolean isArray(Object o) {
    return o != null && o.getClass().isArray();
  }

  static public int arrayLength(Object o) {
    return o != null ? Array.getLength(o) : 0;
  }

  static public JScrollPane jscroll_borderless(Component c) {
    return borderlessScrollPane(jscroll(c));
  }

  static public JTextArea wordWrapTypeWriterTextArea() {
    return wrappedTextArea(newTypeWriterTextArea());
  }

  static public JTextArea wordWrapTypeWriterTextArea(String text) {
    return wrappedTextArea(newTypeWriterTextArea(text));
  }

  static public JFastLogView_noWrap jFastLogView_noWrap() {
    return jFastLogView_noWrap("");
  }

  static public JFastLogView_noWrap jFastLogView_noWrap(String text) {
    return withTypeWriterFont(swingNu(JFastLogView_noWrap.class, text));
  }

  static public JTabbedPane jtabs(Object... x) {
    return fillJTabs(swingNu(JTabbedPane.class), x);
  }

  static public int seconds() {
    return seconds(Calendar.getInstance());
  }

  static public int seconds(Calendar c) {
    return c.get(Calendar.SECOND);
  }

  static public String formatDouble(double d, int digits) {
    String format = digits <= 0 ? "0" : "0." + rep(digits, '#');
    return decimalFormatEnglish(format, d);
  }

  static public String formatDouble(double d) {
    return str(d);
  }

  static public String renderRecordVars(String recordName, Object... params) {
    List<String> l = new ArrayList();
    int i = 0;
    for (; i + 1 < l(params); i += 2) l.add(params[i] + "=" + params[i + 1]);
    return formatFunctionCall(recordName, l);
  }

  static public <A> List<A> syncList() {
    return synchroList();
  }

  static public <A> List<A> syncList(List<A> l) {
    return synchroList(l);
  }

  static public Dimension getPreferredSize(final Component c) {
    return c == null ? null : swing(new F0<Dimension>() {

      public Dimension get() {
        try {
          return c.getPreferredSize();
        } catch (Exception __e) {
          throw rethrow(__e);
        }
      }

      public String toString() {
        return "return c.getPreferredSize();";
      }
    });
  }

  static public Color getBackground(final Component c) {
    return c == null ? null : swing(new F0<Color>() {

      public Color get() {
        try {
          return c.getBackground();
        } catch (Exception __e) {
          throw rethrow(__e);
        }
      }

      public String toString() {
        return "return c.getBackground();";
      }
    });
  }

  static public FontMetrics componentFontMetrics(JComponent c) {
    Font font = getFont(c);
    return font == null ? null : swing(new F0<FontMetrics>() {

      public FontMetrics get() {
        try {
          return c.getFontMetrics(font);
        } catch (Exception __e) {
          throw rethrow(__e);
        }
      }

      public String toString() {
        return "return c.getFontMetrics(font);";
      }
    });
  }

  static public int idiv_ceil(int a, int b) {
    return (a + b - 1) / b;
  }

  static public int idiv_ceil(long a, long b) {
    return toInt_checked((a + b - 1) / b);
  }

  static public <A extends JComponent> A componentPopupMenuItem(A c, final String name, final Object action) {
    componentPopupMenu(c, new VF1<JPopupMenu>() {

      public void get(JPopupMenu menu) {
        try {
          addMenuItem(menu, name, action);
        } catch (Exception __e) {
          throw rethrow(__e);
        }
      }

      public String toString() {
        return "addMenuItem(menu, name, action);";
      }
    });
    return c;
  }

  static public void componentPopupMenuItem(JComponent c, final JMenuItem menuItem) {
    componentPopupMenu(c, new VF1<JPopupMenu>() {

      public void get(JPopupMenu menu) {
        try {
          addMenuItem(menu, menuItem);
        } catch (Exception __e) {
          throw rethrow(__e);
        }
      }

      public String toString() {
        return "addMenuItem(menu, menuItem);";
      }
    });
  }

  static public <A> List<A> asSyncList(Iterable<A> l) {
    return asSynchroList(l);
  }

  static public <A extends Component> A _revalidate(A c) {
    return revalidate(c);
  }

  static public void _revalidate(JFrame f) {
    revalidate(f);
  }

  static public void _revalidate(JInternalFrame f) {
    revalidate(f);
  }

  static public boolean endsWithNewLine(String s) {
    return endsWith(s, "\n");
  }

  static public String lines_rtrimIf(boolean rtrim, List<String> lines) {
    return rtrim ? lines_rtrim(lines) : lines(lines);
  }

  static public String copyTextToClipboard(Object _text) {
    String text = str(_text);
    StringSelection selection = new StringSelection(text);
    Toolkit.getDefaultToolkit().getSystemClipboard().setContents(selection, selection);
    vmBus_send("newClipboardContents", text);
    return text;
  }

  static public Object[] toObjectArray(Collection c) {
    return toObjectArray((Iterable) c);
  }

  static public Object[] toObjectArray(Iterable c) {
    List l = asList(c);
    return l.toArray(new Object[l.size()]);
  }

  static public String toString(Object o) {
    return strOrNull(o);
  }

  static public boolean objectArraysEqual(Object[] a, Object[] b) {
    return arraysEqual(a, b);
  }

  static public int hashAboutObjects(Object... l) {
    int hash = 0, n = l(l);
    for (int i = 0; i < n; i++) hash = boostHashCombine(hash, hashCode(l[i]));
    return hash;
  }

  static public Object[] mapObjectArray(IF1 f, Object[] l) {
    if (empty(l))
      return l;
    int n = l.length;
    Object[] a2 = new Object[n];
    for (int i = 0; i < n; i++) a2[i] = f.get(l[i]);
    return a2;
  }

  static public <A, B> MultiMap<A, B> descTreeMultiMap() {
    return new MultiMap(descTreeMap());
  }

  static public <A> A optPar(ThreadLocal<A> tl, A defaultValue) {
    A a = tl.get();
    if (a != null) {
      tl.set(null);
      return a;
    }
    return defaultValue;
  }

  static public <A> A optPar(ThreadLocal<A> tl) {
    return optPar(tl, null);
  }

  static public Object optPar(Object[] params, String name) {
    return optParam(params, name);
  }

  static public Object optPar(String name, Object[] params) {
    return optParam(params, name);
  }

  static public Object optPar(String name, Map params) {
    return optParam(name, params);
  }

  static public <A> A optPar(Object[] params, String name, A defaultValue) {
    return optParam(params, name, defaultValue);
  }

  static public <A> A optPar(String name, Object[] params, A defaultValue) {
    return optParam(params, name, defaultValue);
  }

  static public List<String> scoredSearch_prepare(String query) {
    return map(__77 -> replacePlusWithSpace(__77), splitAtSpace(query));
  }

  static public float score(Scored s) {
    return s == null ? 0 : s.score();
  }

  static public double scoredSearch_scoreWeighted2(Collection<Pair<String, Double>> l, List<String> words) {
    double score = 0;
    if (l != null)
      for (Pair<String, Double> __0 : l) {
        String s = pairA(__0);
        double weight = pairB(__0);
        score += scoredSearch_score(s, words) * weight;
      }
    return score;
  }

  static public int scoredSearch_score(Iterable<String> l, List<String> words) {
    int score = 0;
    if (l != null)
      for (String s : l) score += scoredSearch_score(s, words);
    return score;
  }

  static public int scoredSearch_score(String s, List<String> words) {
    int score = 0;
    if (nempty(s))
      for (String word : unnullForIteration(words)) score += scoredSearch_score_single(s, word);
    return score;
  }

  static public int scoredSearch_score(String s, String query) {
    return scoredSearch_score(s, scoredSearch_prepare(query));
  }

  static public <A, B> List<B> pairsB(Collection<Pair<A, B>> l) {
    return secondOfPairs(l);
  }

  static public <A, B> IterableIterator<Pair<A, B>> multiMapPairIterator(MultiMap<A, B> mm) {
    return nestedIterator(iterator(keys(mm.data)), key -> (IterableIterator<Pair<A, B>>) mapI(iterator(mm.data.get(key)), val -> pair(key, val)));
  }

  static public <A, B> IterableIterator<Pair<A, B>> multiMapPairIterator_transformValueList(MultiMap<A, B> mm, IF1<List<B>, List<B>> f) {
    return nestedIterator(iterator(keys(mm.data)), key -> (IterableIterator<Pair<A, B>>) mapI(iterator(f.get(mm.data.get(key))), val -> pair(key, val)));
  }

  static public int toIntPercent(double ratio) {
    return roundToInt(ratio * 100);
  }

  static public int toIntPercent(float ratio) {
    return toIntPercent((double) ratio);
  }

  static public <A> List<A> reversedList(Iterable<A> l) {
    List<A> x = cloneList(l);
    Collections.reverse(x);
    return x;
  }

  static public String reversedString(String s) {
    return reverseString(s);
  }

  static public BigInteger bigint(String s) {
    return new BigInteger(s);
  }

  static public BigInteger bigint(long l) {
    return BigInteger.valueOf(l);
  }

  static public Set asSet(Object[] array) {
    HashSet set = new HashSet();
    for (Object o : array) if (o != null)
      set.add(o);
    return set;
  }

  static public Set<String> asSet(String[] array) {
    TreeSet<String> set = new TreeSet();
    for (String o : array) if (o != null)
      set.add(o);
    return set;
  }

  static public <A> Set<A> asSet(Iterable<A> l) {
    if (l instanceof Set)
      return (Set) l;
    HashSet<A> set = new HashSet();
    for (A o : unnull(l)) if (o != null)
      set.add(o);
    return set;
  }

  static public <A> Set<A> asSet(MultiSet<A> ms) {
    return ms == null ? null : ms.asSet();
  }

  static public Complex complex(double re, double im) {
    return new Complex(re, im);
  }

  static public Complex complex(double re) {
    return new Complex(re, 0.0);
  }

  static public Complex complex(double[] reIm) {
    if (empty(reIm))
      return null;
    if (l(reIm) != 2)
      throw fail("Need 2 doubles to make complex number");
    return complex(reIm[0], reIm[1]);
  }

  static public BufferedImage whiteImage(int w, int h) {
    return newBufferedImage(w, h, Color.white);
  }

  static public BufferedImage whiteImage(int size) {
    return whiteImage(size, size);
  }

  static public BufferedImage whiteImage(WidthAndHeight size) {
    return whiteImage(size.getWidth(), size.getHeight());
  }

  static public BufferedImage bufferedImage(int[] pixels, int w, int h) {
    return intArrayToBufferedImage(pixels, w, h);
  }

  static public BufferedImage bufferedImage(int[] pixels, WidthAndHeight size) {
    return bufferedImage(pixels, size.getWidth(), size.getHeight());
  }

  static public BufferedImage bufferedImage(int w, int h, int[] pixels) {
    return intArrayToBufferedImage(pixels, w, h);
  }

  static public BufferedImage bufferedImage(int w, int h) {
    return newBufferedImage(w, h);
  }

  static public BufferedImage bufferedImage(int w, int h, RGB rgb) {
    return newBufferedImage(w, h, rgb);
  }

  static public BufferedImage bufferedImage(int w, Color color) {
    return bufferedImage(w, w, color);
  }

  static public BufferedImage bufferedImage(int w, int h, Color color) {
    return newBufferedImage(w, h, color);
  }

  static public BufferedImage bufferedImage(Pt p, Color color) {
    return newBufferedImage(p, color);
  }

  static public BufferedImage bufferedImage(WidthAndHeight size, Color color) {
    return newBufferedImage(size.w(), size.h(), color);
  }

  static public BufferedImage bufferedImage(Color color, WidthAndHeight size) {
    return bufferedImage(size, color);
  }

  static public int random_incl(int min, int max) {
    return random_incl(min, max, defaultRandomizer());
  }

  static public int random_incl(int min, int max, Random random) {
    return random(min, max + 1, random);
  }

  static public int random_incl(int max) {
    return random(0, max + 1);
  }

  static public Rect translateRect(int x, int y, Rect r) {
    return translateRect(r, x, y);
  }

  static public Rect translateRect(Rect r, int x, int y) {
    return r == null ? null : new Rect(r.x + x, r.y + y, r.w, r.h);
  }

  static public ThreadLocal<BufferedImage> currentImage_var = new ThreadLocal();

  static public BufferedImage currentImage() {
    return currentImage_var.get();
  }

  static public void currentImage(BufferedImage img) {
    currentImage_var.set(img);
  }

  static public int toInt(Object o) {
    if (o == null)
      return 0;
    if (o instanceof Number)
      return ((Number) o).intValue();
    if (o instanceof String)
      return parseInt((String) o);
    if (o instanceof Boolean)
      return boolToInt((Boolean) o);
    throw fail("woot not int: " + getClassName(o));
  }

  static public int toInt(long l) {
    if (l != (int) l)
      throw fail("Too large for int: " + l);
    return (int) l;
  }

  static public boolean canCallWithVarargs(Object o, String method, Object... args) {
    if (o == null)
      return false;
    if (o instanceof Class) {
      Class c = (Class) o;
      _MethodCache cache = callOpt_getCache(c);
      if (cache.findStaticMethod(method, args) != null)
        return true;
      List<Method> methods = cache.cache.get(method);
      if (methods != null)
        methodSearch: for (Method m : methods) {
          {
            if (!(m.isVarArgs() && isStaticMethod(m)))
              continue;
          }
          if (massageArgsForVarArgsCall(m, args) != null)
            return true;
        }
    } else {
      Class c = o.getClass();
      _MethodCache cache = callOpt_getCache(c);
      if (cache.findMethod(method, args) != null)
        return true;
      List<Method> methods = cache.cache.get(method);
      if (methods != null)
        methodSearch: for (Method m : methods) {
          {
            if (!(m.isVarArgs()))
              continue;
          }
          if (massageArgsForVarArgsCall(m, args) != null)
            return true;
        }
    }
    return false;
  }

  static public void smartSet(Field f, Object o, Object value) throws Exception {
    try {
      f.set(o, value);
    } catch (Exception e) {
      Class type = f.getType();
      if (type == int.class && value instanceof Long) {
        f.set(o, ((Long) value).intValue());
        return;
      }
      if (type == boolean.class && value instanceof String) {
        f.set(o, isTrueOrYes(((String) value)));
        return;
      }
      if (type == LinkedHashMap.class && value instanceof Map) {
        f.set(o, asLinkedHashMap((Map) value));
        return;
      }
      try {
        if (f.getType() == Concept.Ref.class) {
          f.set(o, ((Concept) o).new Ref((Concept) value));
          return;
        }
        if (o instanceof Concept.Ref) {
          f.set(o, ((Concept.Ref) o).get());
          return;
        }
      } catch (Throwable _e) {
      }
      throw e;
    }
  }

  static public Object nuObject(String className, Object... args) {
    try {
      return nuObject(classForName(className), args);
    } catch (Exception __e) {
      throw rethrow(__e);
    }
  }

  static public <A> A nuObject(Class<A> c, Object... args) {
    try {
      if (args == null || args.length == 0)
        return nuObjectWithoutArguments(c);
      Constructor m = nuObject_findConstructor(c, args);
      makeAccessible(m);
      return (A) m.newInstance(args);
    } catch (Exception __e) {
      throw rethrow(__e);
    }
  }

  static public Constructor nuObject_findConstructor(Class c, Object... args) {
    for (Constructor m : getDeclaredConstructors_cached(c)) {
      if (!nuObject_checkArgs(m.getParameterTypes(), args, false))
        continue;
      return m;
    }
    throw fail("Constructor " + c.getName() + getClasses(args) + " not found" + (args.length == 0 && (c.getModifiers() & java.lang.reflect.Modifier.STATIC) == 0 ? " - hint: it's a non-static class!" : ""));
  }

  static public boolean nuObject_checkArgs(Class[] types, Object[] args, boolean debug) {
    if (types.length != args.length) {
      if (debug)
        System.out.println("Bad parameter length: " + args.length + " vs " + types.length);
      return false;
    }
    for (int i = 0; i < types.length; i++) if (!(args[i] == null || isInstanceX(types[i], args[i]))) {
      if (debug)
        System.out.println("Bad parameter " + i + ": " + args[i] + " vs " + types[i]);
      return false;
    }
    return true;
  }

  static public Class<?> _getClass(String name) {
    try {
      return Class.forName(name);
    } catch (ClassNotFoundException e) {
      return null;
    }
  }

  static public Class _getClass(Object o) {
    return o == null ? null : o instanceof Class ? (Class) o : o.getClass();
  }

  static public Class _getClass(Object realm, String name) {
    try {
      return classLoaderForObject(realm).loadClass(classNameToVM(name));
    } catch (ClassNotFoundException e) {
      return null;
    }
  }

  static public Method findMethod_cached(Object o, String method, Object... args) {
    try {
      if (o == null)
        return null;
      if (o instanceof Class) {
        _MethodCache cache = callOpt_getCache((Class) o);
        List<Method> methods = cache.cache.get(method);
        if (methods != null)
          for (Method m : methods) if (isStaticMethod(m) && findMethod_checkArgs(m, args, false))
            return m;
        return null;
      } else {
        _MethodCache cache = callOpt_getCache(o.getClass());
        List<Method> methods = cache.cache.get(method);
        if (methods != null)
          for (Method m : methods) if (findMethod_checkArgs(m, args, false))
            return m;
        return null;
      }
    } catch (Exception __e) {
      throw rethrow(__e);
    }
  }

  static public AutoCloseable tempSetField(Object o, String field, Object value) {
    final Object oldValue = get(o, field);
    set(o, field, value);
    return () -> set(o, field, oldValue);
  }

  static public <A> AutoCloseable tempSetField(ISetAndGet<A> gs, A value) {
    if (gs == null)
      return null;
    A oldValue = gs.get();
    gs.set(value);
    return () -> gs.set(oldValue);
  }

  static public <A> AutoCloseable tempSetField(A value, ISetAndGet<A> gs) {
    return tempSetField(gs, value);
  }

  static public void printNumberedLines(Map map) {
    printNumberedLines(mapToLines(map));
  }

  static public void printNumberedLines(String prefix, Map map) {
    printNumberedLines(prefix, mapToLines(map));
  }

  static public <A extends Iterable> A printNumberedLines(A l) {
    int i = 0;
    if (l != null)
      for (Object a : cloneList(l)) print((++i) + ". " + str(a));
    return l;
  }

  static public <A extends Iterable> A printNumberedLines(String prefix, A l) {
    int i = 0;
    if (l != null)
      for (Object a : cloneList(l)) print(prefix + (++i) + ". " + str(a));
    return l;
  }

  static public void printNumberedLines(Object[] l) {
    printNumberedLines("", l);
  }

  static public void printNumberedLines(String prefix, Object[] l) {
    printNumberedLines(prefix, wrapAsList(l));
  }

  static public void printNumberedLines(Object o) {
    printNumberedLines(lines(str(o)));
  }

  static public IMeta toIMeta(Object o) {
    return initIMeta(o);
  }

  static public IMeta initIMeta(Object o) {
    if (o == null)
      return null;
    if (o instanceof IMeta)
      return ((IMeta) o);
    if (o instanceof JComponent)
      return initMetaOfJComponent((JComponent) o);
    if (o instanceof BufferedImage)
      return optCast(IMeta.class, ((BufferedImage) o).getProperty("meta"));
    return null;
  }

  static public Map makeObjectMetaMap() {
    return new CompactHashMap();
  }

  static public IAutoCloseableF0 tempMetaMutex(IMeta o) {
    return o == null ? null : o._tempMetaMutex();
  }

  static public <A, B> void syncMapPut2(Map<A, B> map, A key, B value) {
    if (map != null && key != null)
      synchronized (collectionMutex(map)) {
        if (value != null)
          map.put(key, value);
        else
          map.remove(key);
      }
  }

  static public Map<Thread, Object> vm_threadInterruptionReasonsMap() {
    return vm_generalWeakSubMap("Thread interruption reasons");
  }

  static public String strOr(Object o, String ifNull) {
    return o == null ? ifNull : str(o);
  }

  static public void lockOrFail(Lock lock, long timeout) {
    try {
      ping();
      vmBus_send("locking", lock, "thread", currentThread());
      if (!lock.tryLock(timeout, TimeUnit.MILLISECONDS)) {
        String s = "Couldn't acquire lock after " + timeout + " ms.";
        if (lock instanceof ReentrantLock) {
          ReentrantLock l = (ReentrantLock) lock;
          s += " Hold count: " + l.getHoldCount() + ", owner: " + call(l, "getOwner");
        }
        throw fail(s);
      }
      vmBus_send("locked", lock, "thread", currentThread());
      ping();
    } catch (Exception __e) {
      throw rethrow(__e);
    }
  }

  static public ReentrantLock fairLock() {
    return new ReentrantLock(true);
  }

  static public <A> Set<A> syncLinkedHashSet() {
    return synchroLinkedHashSet();
  }

  static public String dropNumberPrefix(String s) {
    return dropFirst(s, indexOfNonDigit(s));
  }

  static public <A> void replaceLastElement(List<A> l, A a) {
    if (nempty(l))
      l.set(l(l) - 1, a);
  }

  static public String strUnnull(Object o) {
    return o == null ? "" : str(o);
  }

  static public String jlabel_textAsHTML_center_ifNeeded(String text) {
    if (swic(text, "<html>") && ewic(text, "</html>"))
      return text;
    if (!containsNewLines(text))
      return text;
    return jlabel_textAsHTML_center(text);
  }

  static public <A, B> void copyMap(Map<? extends A, ? extends B> a, Map<A, B> b) {
    if (a == null || b == null)
      return;
    b.clear();
    b.putAll(a);
  }

  static public String assertIsIdentifier(String s) {
    if (!isIdentifier(s))
      throw fail("Not an identifier: " + quote(s));
    return s;
  }

  static public String assertIsIdentifier(String msg, String s) {
    if (!isIdentifier(s))
      throw fail(msg + " - Not an identifier: " + quote(s));
    return s;
  }

  static public void printVars_str(Object... params) {
    print(renderVars_str(params));
  }

  static public void printShortenedFunctionCall(Object fname, Object... args) {
    printShortenedFunctionCall(100, fname, args);
  }

  static public void printShortenedFunctionCall(int len, Object fname, Object... args) {
    print(shorten(len, formatFunctionCall(fname, args)));
  }

  static public boolean isDigit(char c) {
    return Character.isDigit(c);
  }

  static public boolean startsWithIgnoreCase(String a, String b) {
    return regionMatchesIC(a, 0, b, 0, b.length());
  }

  static public int hexToInt(String s) {
    return Integer.parseInt(s, 16);
  }

  static public String[] drop(int n, String[] a) {
    n = Math.min(n, a.length);
    String[] b = new String[a.length - n];
    System.arraycopy(a, n, b, 0, b.length);
    return b;
  }

  static public Object[] drop(int n, Object[] a) {
    n = Math.min(n, a.length);
    Object[] b = new Object[a.length - n];
    System.arraycopy(a, n, b, 0, b.length);
    return b;
  }

  static public _MethodCache getMethodCache(Class c) {
    return callOpt_getCache(c);
  }

  static public Map<Class, Constructor[]> getDeclaredConstructors_cached_cache = newDangerousWeakHashMap();

  static public Constructor[] getDeclaredConstructors_cached(Class c) {
    Constructor[] ctors;
    synchronized (getDeclaredConstructors_cached_cache) {
      ctors = getDeclaredConstructors_cached_cache.get(c);
      if (ctors == null) {
        getDeclaredConstructors_cached_cache.put(c, ctors = c.getDeclaredConstructors());
        for (var ctor : ctors) makeAccessible(ctor);
      }
    }
    return ctors;
  }

  static public <A> A[] arrayOfType(Class<A> type, int n) {
    return makeArray(type, n);
  }

  static public <A> A[] arrayOfType(int n, Class<A> type) {
    return arrayOfType(type, n);
  }

  static public String shortenClassName(String name) {
    if (name == null)
      return null;
    int i = lastIndexOf(name, "$");
    if (i < 0)
      i = lastIndexOf(name, ".");
    return i < 0 ? name : substring(name, i + 1);
  }

  static public String longestPrefixInNavigableSet(String s, NavigableSet<String> set) {
    if (set == null || s == null)
      return null;
    while (licensed()) {
      String key = set.floor(s);
      if (key == null)
        break;
      int n = lCommonPrefix(key, s);
      if (n == l(key))
        return key;
      s = takeFirst(s, n);
    }
    return null;
  }

  static public IF0<PingSource> ping_v3_pingSourceMaker_cache;

  static public IF0<PingSource> ping_v3_pingSourceMaker() {
    if (ping_v3_pingSourceMaker_cache == null)
      ping_v3_pingSourceMaker_cache = ping_v3_pingSourceMaker_load();
    return ping_v3_pingSourceMaker_cache;
  }

  static public IF0<PingSource> ping_v3_pingSourceMaker_load() {
    return or((IF0) vm_generalMap_get("ping_v3_pingSourceMaker"), () -> null);
  }

  static public char charAt(String s, int i) {
    return s != null && i >= 0 && i < s.length() ? s.charAt(i) : '\0';
  }

  static public <A, B> int lKeys(MultiMap<A, B> mm) {
    return mm == null ? 0 : mm.keysSize();
  }

  static public Iterator emptyIterator() {
    return Collections.emptyIterator();
  }

  static public Method findMethodNamed(Object obj, String method) {
    if (obj == null)
      return null;
    if (obj instanceof Class)
      return findMethodNamed((Class) obj, method);
    return findMethodNamed(obj.getClass(), method);
  }

  static public Method findMethodNamed(Class c, String method) {
    while (c != null) {
      for (Method m : c.getDeclaredMethods()) if (m.getName().equals(method)) {
        makeAccessible(m);
        return m;
      }
      c = c.getSuperclass();
    }
    return null;
  }

  static public int hashMap_internalHash(Object key) {
    int h;
    return (key == null) ? 0 : (h = key.hashCode()) ^ (h >>> 16);
  }

  static public String renderFunctionCall(String fname, Object... args) {
    return formatFunctionCall(fname, args);
  }

  static public <A> A assertEqualsVerbose(Object x, A y) {
    assertEqualsVerbose((String) null, x, y);
    return y;
  }

  static public <A> A assertEqualsVerbose(String msg, Object x, A y) {
    if (!eq(x, y)) {
      throw fail((nempty(msg) ? msg + ": " : "") + "expected: " + x + ", got: " + y);
    } else
      print("OK" + (empty(msg) ? "" : " " + msg) + ": " + (x));
    return y;
  }

  static public Class<?> hotwire(String src) {
    return hotwire(src, __1 -> mainClassNameForClassLoader(__1));
  }

  static public Class<?> hotwire(String src, IF1<ClassLoader, String> calculateMainClass) {
    assertFalse(_inCore());
    Class j = getJavaX();
    if (isAndroid()) {
      synchronized (j) {
        List<File> libraries = new ArrayList<File>();
        File srcDir = (File) call(j, "transpileMain", src, libraries);
        if (srcDir == null)
          throw fail("transpileMain returned null (src=" + quote(src) + ")");
        Object androidContext = get(j, "androidContext");
        return (Class) call(j, "loadx2android", srcDir, src);
      }
    } else {
      Class c = (Class) (call(j, "hotwire", src));
      hotwire_copyOver(c);
      return c;
    }
  }

  static public <A> A callMain(A c, String... args) {
    callOpt(c, "main", new Object[] { args });
    return c;
  }

  static public void callMain() {
    callMain(mc());
  }

  static public String hfulltag(String tag) {
    return hfulltag(tag, "");
  }

  static public String hfulltag(String tag, Object contents, Object... params) {
    return hopeningTag(tag, params) + str(contents) + "</" + tag + ">";
  }

  static public String tag(String tag) {
    return htag(tag);
  }

  static public String tag(String tag, Object contents, Object... params) {
    return htag(tag, str(contents), params);
  }

  static public String tag(String tag, StringBuilder contents, Object... params) {
    return htag(tag, contents, params);
  }

  static public String tag(String tag, StringBuffer contents, Object... params) {
    return htag(tag, contents, params);
  }

  static public String joinNempties(String sep, Object... strings) {
    return joinStrings(sep, strings);
  }

  static public String joinNempties(String sep, Iterable strings) {
    return joinStrings(sep, strings);
  }

  static public List flattenCollectionsAndArrays(Iterable a) {
    List l = new ArrayList();
    for (Object x : a) if (x instanceof Collection)
      l.addAll(flattenCollectionsAndArrays((Collection) x));
    else if (x instanceof Object[])
      l.addAll(flattenCollectionsAndArrays(asList((Object[]) x)));
    else
      l.add(x);
    return l;
  }

  static public int identityHash(Object o) {
    return identityHashCode(o);
  }

  static public Random defaultRandomGenerator() {
    {
      Random r = customRandomizerForThisThread();
      if (r != null)
        return r;
    }
    return ThreadLocalRandom.current();
  }

  static public Random getRandomizer(Random r) {
    return r != null ? r : defaultRandomGenerator();
  }

  static public <A> A oneOf(List<A> l) {
    if (empty(l))
      return null;
    int n = l.size();
    return n == 1 ? first(l) : l.get(defaultRandomizer().nextInt(n));
  }

  static public char oneOf(String s) {
    return empty(s) ? '?' : s.charAt(random(l(s)));
  }

  static public String oneOf(String... l) {
    return oneOf(asList(l));
  }

  static public <A> A collectionGet(Collection<A> c, int idx) {
    if (c == null || idx < 0 || idx >= l(c))
      return null;
    if (c instanceof List)
      return listGet((List<A>) c, idx);
    Iterator<A> it = c.iterator();
    for (int i = 0; i < idx; i++) if (it.hasNext())
      it.next();
    else
      return null;
    return it.hasNext() ? it.next() : null;
  }

  static public <A, B> Pair<A, B> entryToPair(Map.Entry<A, B> e) {
    return mapEntryToPair(e);
  }

  static public <A, B> Set<Map.Entry<A, B>> entries(Map<A, B> map) {
    return _entrySet(map);
  }

  static public <A> List<A> cloneSubList(List<A> l, int startIndex, int endIndex) {
    return newSubList(l, startIndex, endIndex);
  }

  static public <A> List<A> cloneSubList(List<A> l, int startIndex) {
    return newSubList(l, startIndex);
  }

  static public String formatWithThousands(long l) {
    return formatWithThousandsSeparator(l);
  }

  static public double fraction(double d) {
    return d % 1;
  }

  static public String n_fancy2(long l, String singular, String plural) {
    return formatWithThousandsSeparator(l) + " " + trim(l == 1 ? singular : plural);
  }

  static public String n_fancy2(Collection l, String singular, String plural) {
    return n_fancy2(l(l), singular, plural);
  }

  static public String n_fancy2(Map m, String singular, String plural) {
    return n_fancy2(l(m), singular, plural);
  }

  static public String n_fancy2(Object[] a, String singular, String plural) {
    return n_fancy2(l(a), singular, plural);
  }

  static public String n_fancy2(MultiSet ms, String singular, String plural) {
    return n_fancy2(l(ms), singular, plural);
  }

  static public ImageSurface imageSurface(BufferedImage img) {
    return swingNu(ImageSurface.class, img);
  }

  static public ImageSurface imageSurface(MakesBufferedImage img) {
    return swingNu(ImageSurface.class, img);
  }

  static public ImageSurface imageSurface() {
    return swingNu(ImageSurface.class);
  }

  static public void imageSurface_pixelated(ImageSurface imageSurface) {
    if (imageSurface == null)
      return;
    imageSurface.setDoubleBuffered(true);
    imageSurface.noAlpha = true;
    imageSurface.interpolationMode = RenderingHints.VALUE_INTERPOLATION_NEAREST_NEIGHBOR;
    repaint(imageSurface);
  }

  static public void imageSurface_pixelated(ImageSurface imageSurface, boolean pixelated) {
    if (pixelated)
      imageSurface_pixelated(imageSurface);
    else
      imageSurface_unpixelated(imageSurface);
  }

  static public File programDir_mine;

  static public File programDir() {
    return programDir(getProgramID());
  }

  static public File programDir(String snippetID) {
    boolean me = sameSnippetID(snippetID, programID());
    if (programDir_mine != null && me)
      return programDir_mine;
    File dir = new File(javaxDataDir(), formatSnippetIDOpt(snippetID));
    if (me) {
      String c = caseID();
      if (nempty(c))
        dir = newFile(dir, c);
    }
    return dir;
  }

  static public File programDir(String snippetID, String subPath) {
    return new File(programDir(snippetID), subPath);
  }

  static public String dbProgramID() {
    return getDBProgramID();
  }

  static public BufferedImage toBufferedImageOpt(Object o) {
    if (o instanceof BufferedImage)
      return ((BufferedImage) o);
    if (o instanceof Image)
      return copyImage((Image) o);
    if (o instanceof MakesBufferedImage)
      return ((MakesBufferedImage) o).getBufferedImage();
    String c = getClassName(o);
    if (eqOneOf(c, "main$BWImage", "main$RGBImage"))
      return (BufferedImage) call(o, "getBufferedImage");
    return null;
  }

  static public ThreadLocal<Boolean> assertVerbose_value = new ThreadLocal();

  static public void assertVerbose(boolean b) {
    assertVerbose_value.set(b);
  }

  static public boolean assertVerbose() {
    return isTrue(assertVerbose_value.get());
  }

  static public String nullIfEmpty(String s) {
    return isEmpty(s) ? null : s;
  }

  static public <A, B> Map<A, B> nullIfEmpty(Map<A, B> map) {
    return isEmpty(map) ? null : map;
  }

  static public <A> List<A> nullIfEmpty(List<A> l) {
    return isEmpty(l) ? null : l;
  }

  static public String _userHome;

  static public String userHome() {
    if (_userHome == null)
      return actualUserHome();
    return _userHome;
  }

  static public File userHome(String path) {
    return new File(userDir(), path);
  }

  static public File touchFile(File file) {
    try {
      closeRandomAccessFile(newRandomAccessFile(mkdirsForFile(file), "rw"));
      return file;
    } catch (Exception __e) {
      throw rethrow(__e);
    }
  }

  static public boolean removeFile(File file) {
    return deleteFile(file);
  }

  static public List<String> toLinesFullTrim(String s) {
    List<String> l = new ArrayList();
    for (String line : toLines(s)) if (nempty(line = trim(line)))
      l.add(line);
    return l;
  }

  static public List<String> toLinesFullTrim(File f) {
    List<String> l = new ArrayList();
    for (String line : linesFromFile(f)) if (nempty(line = trim(line)))
      l.add(line);
    return l;
  }

  static public ThreadLocal<VF1<File>> checkFileNotTooBigToRead_tl = new ThreadLocal();

  static public void checkFileNotTooBigToRead(File f) {
    callF(checkFileNotTooBigToRead_tl.get(), f);
  }

  public static File mkdirsForFile(File file) {
    File dir = file.getParentFile();
    if (dir != null) {
      dir.mkdirs();
      if (!dir.isDirectory())
        if (dir.isFile())
          throw fail("Please delete the file " + f2s(dir) + " - it is supposed to be a directory!");
        else
          throw fail("Unknown IO exception during mkdirs of " + f2s(file));
    }
    return file;
  }

  public static String mkdirsForFile(String path) {
    mkdirsForFile(new File(path));
    return path;
  }

  static public File copyFile(File src, File dest) {
    try {
      FileInputStream inputStream = new FileInputStream(src.getPath());
      FileOutputStream outputStream = newFileOutputStream(dest.getPath());
      try {
        copyStream(inputStream, outputStream);
        inputStream.close();
      } finally {
        outputStream.close();
      }
      return dest;
    } catch (Exception __e) {
      throw rethrow(__e);
    }
  }

  static public FileOutputStream newFileOutputStream(File path) throws IOException {
    return newFileOutputStream(path.getPath());
  }

  static public FileOutputStream newFileOutputStream(String path) throws IOException {
    return newFileOutputStream(path, false);
  }

  static public FileOutputStream newFileOutputStream(File path, boolean append) throws IOException {
    return newFileOutputStream(path.getPath(), append);
  }

  static public FileOutputStream newFileOutputStream(String path, boolean append) throws IOException {
    mkdirsForFile(path);
    FileOutputStream f = new FileOutputStream(path, append);
    _registerIO(f, path, true);
    return f;
  }

  static public String fromLines(Iterable lines) {
    StringBuilder buf = new StringBuilder();
    if (lines != null)
      for (Object line : lines) buf.append(str(line)).append('\n');
    return buf.toString();
  }

  static public String fromLines(String... lines) {
    return fromLines(asList(lines));
  }

  static public IterableIterator<String> toLines(File f) {
    return linesFromFile(f);
  }

  static public List<String> toLines(String s) {
    List<String> lines = new ArrayList<String>();
    if (s == null)
      return lines;
    int start = 0;
    while (true) {
      int i = toLines_nextLineBreak(s, start);
      if (i < 0) {
        if (s.length() > start)
          lines.add(s.substring(start));
        break;
      }
      lines.add(s.substring(start, i));
      if (s.charAt(i) == '\r' && i + 1 < s.length() && s.charAt(i + 1) == '\n')
        i += 2;
      else
        ++i;
      start = i;
    }
    return lines;
  }

  static public int toLines_nextLineBreak(String s, int start) {
    int n = s.length();
    for (int i = start; i < n; i++) {
      char c = s.charAt(i);
      if (c == '\r' || c == '\n')
        return i;
    }
    return -1;
  }

  static public List<String> mapToLines(Map map) {
    List<String> l = new ArrayList();
    for (Object key : keys(map)) l.add(str(key) + " = " + str(map.get(key)));
    return l;
  }

  static public String mapToLines(Map map, Object f) {
    return lines(map(map, f));
  }

  static public String mapToLines(Object f, Map map) {
    return lines(map(map, f));
  }

  static public String mapToLines(Object f, Iterable l) {
    return lines(map(f, l));
  }

  static public <A> String mapToLines(Iterable<A> l, IF1<A, String> f) {
    return mapToLines((Object) f, l);
  }

  static public <A> String mapToLines(IF1<A, String> f, Iterable<A> l) {
    return mapToLines((Object) f, l);
  }

  static public <A, B> String mapToLines(Map<A, B> map, IF2<A, B, String> f) {
    return lines(map(map, f));
  }

  static public <A> String mapToLines(IF1<A, String> f, A data1, A... moreData) {
    return lines(map(f, data1, moreData));
  }

  static public <A extends Component> A jPreferHeight(int h, A c) {
    Dimension size = c.getPreferredSize();
    c.setPreferredSize(new Dimension(size.width, max(h, size.height)));
    return c;
  }

  static public boolean odd(int i) {
    return (i & 1) != 0;
  }

  static public boolean odd(long i) {
    return (i & 1) != 0;
  }

  static public boolean odd(BigInteger i) {
    return odd(toInt(i));
  }

  static public boolean isSpaceEtc(char c) {
    return c == ' ' || c == '\t' || c == '\r' || c == '\n';
  }

  static public File fileAppendToName(File f, String suffix) {
    return newFile(f.getPath() + suffix);
  }

  static public <A extends Concept> A uniqueConcept(Class<A> c, Object... params) {
    return uniqueConcept(db_mainConcepts(), c, params);
  }

  static public <A extends Concept> A uniqueConcept(Concepts cc, Class<A> c, Object... params) {
    AutoCloseable __1 = tempDBLock(cc);
    try {
      params = expandParams(c, params);
      A x = findConceptWhere(cc, c, params);
      if (x == null) {
        x = unlisted(c);
        csetAll(x, params);
        cc.register(x);
      } else {
      }
      return x;
    } finally {
      _close(__1);
    }
  }

  static public AutoCloseable tempDBLock(Concepts concepts) {
    return tempLock(concepts.lock);
  }

  static public AutoCloseable tempDBLock() {
    return tempDBLock(db_mainConcepts());
  }

  static public <A extends Concept> Object[] expandParams(Class<A> c, Object[] params) {
    if (l(params) == 1)
      params = new Object[] { singleFieldName(c), params[0] };
    else
      warnIfOddCount(params);
    return params;
  }

  static public <A extends Concept> A findConceptWhereCI(Class<A> c, Object... params) {
    return findConceptWhereCI(db_mainConcepts(), c, params);
  }

  static public <A extends Concept> A findConceptWhereCI(Concepts concepts, Class<A> c, Object... params) {
    params = expandParams(c, params);
    Lowest<IF0<Collection<A>>> bestIndex = new Lowest();
    if (concepts.ciFieldIndices != null)
      for (int i = 0; i < l(params); i += 2) {
        ping();
        Object val = params[i + 1];
        IFieldIndex<A, Object> index = concepts.getCIFieldIndex(c, (String) params[i]);
        if (index != null) {
          Collection<A> l = index.getAll(val);
          bestIndex.put(() -> l, l(l));
        }
        if (concepts.useBackRefsForSearches && val instanceof Concept) {
          bestIndex.put(() -> findBackRefs(((Concept) val), c), ((Concept) val)._backRefCount());
        }
      }
    if (bestIndex.has()) {
      Collection<A> l = bestIndex.get().get();
      if (l(params) == 2)
        return first(l);
      for (A x : l) {
        ping();
        if (checkConceptFieldsIC(x, params))
          return x;
      }
      return null;
    } else {
      for (A x : concepts.list(c)) {
        ping();
        if (checkConceptFieldsIC(x, params))
          return x;
      }
      return null;
    }
  }

  static public Concept findConceptWhereCI(Concepts concepts, String c, Object... params) {
    for (Concept x : concepts.list(c)) {
      ping();
      if (checkConceptFieldsIC(x, params))
        return x;
    }
    return null;
  }

  static public <A extends Concept> A unlisted(Class<A> c, Object... args) {
    concepts_unlisted.set(true);
    try {
      return nuObject(c, args);
    } finally {
      concepts_unlisted.set(null);
    }
  }

  static public Concept unlisted(String name, Object... args) {
    Class<? extends Concept> cc = findClass(name);
    concepts_unlisted.set(true);
    try {
      return cc != null ? nuObject(cc) : new Concept(name);
    } finally {
      concepts_unlisted.set(null);
    }
  }

  static public int csetAll(Concept c, Object... values) {
    return cset(c, values);
  }

  static public int csetAll(Iterable<? extends Concept> l, Object... values) {
    int n = 0;
    for (Concept c : unnullForIteration(l)) n += cset(c, values);
    return n;
  }

  static public int csetAll(Concept c, Map<String, Object> values) {
    int n = 0;
    for (Map.Entry<? extends String, ? extends Object> __0 : _entrySet(values)) {
      String field = __0.getKey();
      Object value = __0.getValue();
      n += cset(c, field, value);
    }
    return n;
  }

  static public File getProgramFile(String progID, String fileName) {
    if (new File(fileName).isAbsolute())
      return new File(fileName);
    return new File(getProgramDir(progID), fileName);
  }

  static public File getProgramFile(String fileName) {
    return getProgramFile(getProgramID(), fileName);
  }

  static public String conceptsFileName() {
    return "concepts.structure.gz";
  }

  static public List<File> listDirs(File dir) {
    if (dir == null)
      return emptyList();
    File[] files = dir.listFiles();
    List<File> l = new ArrayList();
    if (files != null)
      for (File f : files) if (f.isDirectory())
        l.add(f);
    return l;
  }

  static public List<File> listDirs(String dir) {
    return listDirs(newFile(dir));
  }

  static public boolean isFile(File f) {
    return f != null && f.isFile();
  }

  static public boolean isFile(String path) {
    return isFile(newFile(path));
  }

  static public void close_pcall(AutoCloseable c) {
    if (c != null) {
      try {
        c.close();
      } catch (Throwable __e) {
        printStackTrace(__e);
      }
    }
  }

  static public void preCleanUp(Object c) {
    if (c instanceof Collection) {
      for (Object o : ((Collection) c)) preCleanUp(o);
      return;
    }
    callOpt(c, "licensed_off");
    setOpt_raw(c, "ping_anyActions", true);
    setOpt_raw(c, "cleaningUp_flag", true);
  }

  static public void innerCleanUp(Object c) {
    if (!isFalse(pcallOpt(c, "cleanMeUp")))
      for (String name : sorted(methodsStartingWith(c, "cleanMeUp_"))) try {
        callOpt(c, name);
      } catch (Throwable e) {
        print("Error cleaning up: " + programID(c));
        _handleException(e);
      }
  }

  static public void innerCleanUp() {
    innerCleanUp(mc());
  }

  static public Object pcallOpt(Object o, String method, Object... args) {
    try {
      return callOpt(o, method, args);
    } catch (Throwable __e) {
      printStackTrace(__e);
    }
    return null;
  }

  static public List<Thread> registeredThreads(Object o) {
    Map<Thread, Boolean> map = (Map<Thread, Boolean>) (getOpt(o, "_registerThread_threads"));
    if (map == null)
      return ll();
    map.size();
    synchronized (map) {
      return asList(keys(map));
    }
  }

  static public List<Thread> registeredThreads() {
    _registerThread_threads.size();
    return asList(keys(_registerThread_threads));
  }

  static public void interruptThreads(Collection<Thread> threads) {
    for (Thread t : unnull(threads)) interruptThread(t);
  }

  static public void interruptThreads(Class mainClass) {
    interruptThreads(registeredThreads(mainClass));
  }

  static public void retireClassLoader(ClassLoader cl) {
    if (isJavaXClassLoader(cl))
      setOptAll(cl, "retired", true, "retiredMarker", new DefunctClassLoader());
  }

  static public <A extends Concept> A findConceptWhere(Class<A> c, Object... params) {
    return findConceptWhere(db_mainConcepts(), c, params);
  }

  static public <A extends Concept> A findConceptWhere(Concepts concepts, Class<A> c, Object... params) {
    ping();
    params = expandParams(c, params);
    if (concepts.fieldIndices != null)
      for (int i = 0; i < l(params); i += 2) {
        IFieldIndex<A, Object> index = concepts.getFieldIndex(c, (String) params[i]);
        if (index != null) {
          for (A x : index.getAll(params[i + 1])) if (checkConceptFields(x, params))
            return x;
          return null;
        }
      }
    for (A x : concepts.list(c)) if (checkConceptFields(x, params))
      return x;
    return null;
  }

  static public Concept findConceptWhere(Concepts concepts, String c, Object... params) {
    for (Concept x : concepts.list(c)) if (checkConceptFields(x, params))
      return x;
    return null;
  }

  static public <A extends Concept> A uniq(Class<A> c, Object... params) {
    return uniqueConcept(c, params);
  }

  static public <A extends Concept> A uniq(Concepts cc, Class<A> c, Object... params) {
    return uniqueConcept(cc, c, params);
  }

  static public <A> A waitForVarToBeNotNull(Var<A> v) {
    try {
      synchronized (v) {
        while (!v.has()) v.wait();
        return v.get();
      }
    } catch (Exception __e) {
      throw rethrow(__e);
    }
  }

  static public AutoCloseable tempOnChangeAndNow(IHasChangeListeners src, Runnable listener) {
    if (src == null || listener == null)
      return null;
    src.onChangeAndNow(listener);
    return () -> src.removeChangeListener(listener);
  }

  static public boolean isInstance(Class type, Object arg) {
    return type.isInstance(arg);
  }

  static public double positiveInfinity() {
    return Double.POSITIVE_INFINITY;
  }

  static public double toSeconds(long ms) {
    return ms / 1000.0;
  }

  static public String toSeconds(long ms, int digits) {
    return formatDouble(toSeconds(ms), digits);
  }

  static public double toSeconds(double ms) {
    return ms / 1000.0;
  }

  static public String toSeconds(double ms, int digits) {
    return formatDouble(toSeconds(ms), digits);
  }

  static public Set<Thread> evalWithTimeout_inTime = synchroSet();

  static public Set<Thread> evalWithTimeout_allThreads = newWeakHashSet();

  static public ThreadLocal<String> evalWithTimeout_threadName = new ThreadLocal();

  static public <A> Either<A, Thread> evalWithTimeout(double timeoutSeconds, IF0<A> r) {
    return (Either) evalWithTimeout(timeoutSeconds, (Object) r);
  }

  static public Either<Object, Thread> evalWithTimeout(int timeoutMS, Object r) {
    return evalWithTimeout(toSeconds(timeoutMS), r);
  }

  static public Either<Object, Thread> evalWithTimeout(double timeoutSeconds, Object r) {
    final Flag done = new Flag();
    final Flag doneWaiting = new Flag();
    final Var var = new Var();
    final Var<Throwable> error = new Var();
    var printer = print_byThread().get();
    Thread t = newThread(getAndClearThreadLocal(evalWithTimeout_threadName), new Runnable() {

      public void run() {
        try {
          try {
            AutoCloseable __1 = tempSetTL(print_byThread(), printer);
            try {
              try {
                var.set(callF(r));
              } finally {
                evalWithTimeout_allThreads.remove(currentThread());
              }
            } finally {
              _close(__1);
            }
          } catch (Throwable e) {
            error.set(e);
            if (doneWaiting.isUp())
              printStackTrace_inPossiblyCancelledThread(e);
          } finally {
            done.raise();
          }
        } catch (Exception __e) {
          throw rethrow(__e);
        }
      }

      public String toString() {
        return "try {\r\n      temp tempSetTL(print_byThread(), printer);\r\n      \r\n      try {\r...";
      }
    });
    beforeDelegatingToThread(t);
    try {
      startThread(t);
      evalWithTimeout_inTime.add(t);
      evalWithTimeout_allThreads.add(t);
      try {
        done.waitUntilUp(timeoutSeconds);
        doneWaiting.raise();
      } finally {
        evalWithTimeout_inTime.remove(t);
      }
      if (!done.isUp()) {
        print("Cancelling thread (timeout)");
        cancelAndInterruptThread(t);
        return either2(t);
      }
      if (error.get() != null)
        rethrow(error.get());
      return either1(var.get());
    } finally {
      afterDelegatingToThread(t);
    }
  }

  static public WeakReference<Object> creator_class;

  static public Object creator() {
    return creator_class == null ? null : creator_class.get();
  }

  public static String bytesToHex(byte[] bytes) {
    return bytesToHex(bytes, 0, bytes.length);
  }

  public static String bytesToHex(byte[] bytes, int ofs, int len) {
    StringBuilder stringBuilder = new StringBuilder(len * 2);
    for (int i = 0; i < len; i++) {
      String s = "0" + Integer.toHexString(bytes[ofs + i]);
      stringBuilder.append(s.substring(s.length() - 2, s.length()));
    }
    return stringBuilder.toString();
  }

  static public byte[] toUtf8(String s) {
    try {
      return s.getBytes(utf8charset());
    } catch (Exception __e) {
      throw rethrow(__e);
    }
  }

  static public boolean md5OfFile_verbose = false;

  static public String md5OfFile(String path) {
    return md5OfFile(newFile(path));
  }

  static public String md5OfFile(File f) {
    try {
      if (!f.exists())
        return "-";
      if (md5OfFile_verbose)
        print("Getting MD5 of " + f);
      MessageDigest md5 = MessageDigest.getInstance("MD5");
      FileInputStream in = new FileInputStream(f);
      try {
        byte[] buf = new byte[65536];
        int l;
        while (true) {
          l = in.read(buf);
          if (l <= 0)
            break;
          md5.update(buf, 0, l);
        }
        return bytesToHex(md5.digest());
      } finally {
        _close(in);
      }
    } catch (Exception __e) {
      throw rethrow(__e);
    }
  }

  static public boolean isPrimitiveType(Class c) {
    return c != null && c.isPrimitive();
  }

  static public boolean isArrayType(Class type) {
    return type != null && type.isArray();
  }

  static public Object[] arrayrep(Object a, int n) {
    Object[] array = new Object[n];
    for (int i = 0; i < n; i++) array[i] = a;
    return array;
  }

  static public <A> A[] arrayrep(Class<A> type, A a, int n) {
    A[] array = newArray(type, n);
    for (int i = 0; i < n; i++) array[i] = a;
    return array;
  }

  static public TimerTask timerTask(final Object r, final java.util.Timer timer) {
    return new TimerTask() {

      public void run() {
        if (!licensed())
          timer.cancel();
        else
          pcallF(r);
      }
    };
  }

  static public <A> A vmBus_timerStarted(A timer) {
    vmBus_send("timerStarted", timer, costCenter());
    return timer;
  }

  static public <A> boolean addToCollection(Collection<A> c, A a) {
    return c != null && c.add(a);
  }

  static public int methodApplicabilityScore_withPrimitiveWidening(Executable m, Object[] args) {
    Class<?>[] types = m.getParameterTypes();
    if (types.length != l(args))
      return Integer.MAX_VALUE;
    int score = 0;
    boolean widenings = false;
    for (int i = 0; i < types.length; i++) {
      Object a = args[i];
      Class c = types[i];
      if (a == null) {
        if (c.isPrimitive())
          return Integer.MAX_VALUE;
      } else {
        Class t = a.getClass();
        int s = typeConversionScoreWithUnboxing(t, c);
        if (s == Integer.MAX_VALUE)
          return Integer.MAX_VALUE;
        if (s < 0)
          widenings = true;
        score += abs(s);
      }
    }
    return widenings ? -score : score;
  }

  static public float abs(float f) {
    return Math.abs(f);
  }

  static public int abs(int i) {
    return Math.abs(i);
  }

  static public double abs(double d) {
    return Math.abs(d);
  }

  static public double abs(Complex c) {
    return c.abs();
  }

  static public Object invokeConstructorWithWidening(Constructor m, Object... args) {
    try {
      try {
        Class<?>[] types = m.getParameterTypes();
        int n = types.length;
        Object[] args2 = new Object[n];
        for (int i = 0; i < n; i++) args2[i] = convertPrimitiveIfNecessary(args[i], types[i]);
        return m.newInstance(args2);
      } catch (IllegalArgumentException e) {
        throw new IllegalArgumentException(e.getMessage() + " - was calling: " + m + ", args: " + joinWithSpace(classNames(args)));
      }
    } catch (Exception __e) {
      throw rethrow(__e);
    }
  }

  static public String hostToIP(String host) {
    try {
      for (InetAddress a : InetAddress.getAllByName(host)) {
        String ip = a.getHostAddress();
        if (isIPv4(ip))
          return ip;
      }
      throw fail("No IP address found for " + host);
    } catch (Exception __e) {
      throw rethrow(__e);
    }
  }

  static public Object invokeMethodWithWidening(Method m, Object o, Object... args) {
    try {
      try {
        Class<?>[] types = m.getParameterTypes();
        int n = types.length;
        Object[] args2 = new Object[n];
        for (int i = 0; i < n; i++) args2[i] = convertPrimitiveIfNecessary(args[i], types[i]);
        return m.invoke(o, args2);
      } catch (InvocationTargetException e) {
        throw rethrow(getExceptionCause(e));
      } catch (IllegalArgumentException e) {
        throw new IllegalArgumentException(e.getMessage() + " - was calling: " + m + ", args: " + joinWithSpace(classNames(args)));
      }
    } catch (Exception __e) {
      throw rethrow(__e);
    }
  }

  static public Object callWithVarargs(Object o, String method, Object... args) {
    return call_withVarargs(o, method, args);
  }

  static public int methodApplicabilityScore_onTypes(Method m, Class[] argTypes) {
    return methodApplicabilityScore_onTypes((Executable) m, argTypes);
  }

  static public int methodApplicabilityScore_onTypes(Executable m, Class[] argTypes) {
    Class<?>[] types = m.getParameterTypes();
    if (types.length != argTypes.length)
      return Integer.MAX_VALUE;
    int score = 0;
    for (int i = 0; i < types.length; i++) {
      Class a = argTypes[i];
      Class c = types[i];
      if (c == a) {
      } else if (isSubclassOf(a, c))
        ++score;
      else
        return Integer.MAX_VALUE;
    }
    return score;
  }

  static public Method findSingleInterfaceMethod(Class intrface) {
    return singletonOpt(findNonDefaultInterfaceMethods(intrface));
  }

  static public <A> IterableIterator<A> emptyItIt() {
    return emptyIterableIterator();
  }

  static public <A> IterableIterator<A> arrayIterator(A[] l) {
    return l == null ? null : new IterableIterator<A>() {

      public int i = 0;

      public boolean hasNext() {
        return i < l.length;
      }

      public A next() {
        return l[i++];
      }
    };
  }

  static public <A> IterableIterator<A> iff(Object f) {
    return iteratorFromFunction_withEndMarker(f);
  }

  static public IterableIterator iff(F0 f) {
    return iteratorFromFunction_withEndMarker(f);
  }

  static public <A> IterableIterator iff(IF0 f) {
    return iteratorFromFunction_withEndMarker(f);
  }

  static public Object endMarker() {
    return iteratorFromFunction_endMarker;
  }

  static public ChangeListener changeListener(final Object r) {
    return new ChangeListener() {

      public void stateChanged(ChangeEvent e) {
        pcallF(r);
      }
    };
  }

  static public ItemListener itemListener(final Object r) {
    return new ItemListener() {

      public void itemStateChanged(ItemEvent e) {
        pcallF(r);
      }
    };
  }

  static public void onUpdate(JComponent c, Runnable r) {
    onUpdate(c, (Object) r);
  }

  static public void onUpdate(JTextComponent c, IVF1<String> r) {
    if (c == null || r == null)
      return;
    c.getDocument().addDocumentListener(runnableToDocumentListener(() -> r.get(c.getText())));
  }

  static public void onUpdate(JComponent c, Object r) {
    if (c instanceof JTextComponent)
      ((JTextComponent) c).getDocument().addDocumentListener(runnableToDocumentListener(toRunnable(r)));
    else if (c instanceof ItemSelectable)
      ((ItemSelectable) c).addItemListener(new ItemListener() {

        public void itemStateChanged(ItemEvent e) {
          pcallF(r);
        }
      });
    else if (c instanceof JSpinner)
      onChange(((JSpinner) c), r);
    else
      print("Warning: onUpdate doesn't know " + getClassName(c));
  }

  static public void onUpdate(List<? extends JComponent> l, Object r) {
    for (JComponent c : l) onUpdate(c, r);
  }

  static public <A> A getSelectedItem_typed(JList<A> l) {
    return swing(() -> l.getSelectedValue());
  }

  static public <A> A getSelectedItem_typed(JComboBox<A> cb) {
    return swing(() -> (A) cb.getSelectedItem());
  }

  static public boolean isEditableComboBox(final JComboBox cb) {
    return cb != null && swing(new F0<Boolean>() {

      public Boolean get() {
        try {
          return cb.isEditable();
        } catch (Exception __e) {
          throw rethrow(__e);
        }
      }

      public String toString() {
        return "return cb.isEditable();";
      }
    });
  }

  static public JTextField textFieldFromComboBox(JComboBox cb) {
    return (JTextField) cb.getEditor().getEditorComponent();
  }

  static public JComboBox onSelectedItem(final JComboBox cb, final VF1<String> f) {
    addActionListener(cb, new Runnable() {

      public void run() {
        try {
          pcallF(f, selectedItem(cb));
        } catch (Exception __e) {
          throw rethrow(__e);
        }
      }

      public String toString() {
        return "pcallF(f, selectedItem(cb))";
      }
    });
    return cb;
  }

  static public JComboBox onSelectedItem(final JComboBox cb, IVF1<String> f) {
    addActionListener(cb, new Runnable() {

      public void run() {
        try {
          pcallF(f, selectedItem(cb));
        } catch (Exception __e) {
          throw rethrow(__e);
        }
      }

      public String toString() {
        return "pcallF(f, selectedItem(cb))";
      }
    });
    return cb;
  }

  static public void onUpdateAndNow(JComponent c, final Object r) {
    onUpdate(c, r);
    callF(r);
  }

  static public void onUpdateAndNow(JTextComponent c, IVF1<String> r) {
    swing(() -> {
      if (c == null)
        return;
      onUpdate(c, r);
      callF(r, c.getText());
    });
  }

  static public void onUpdateAndNow(List<? extends JComponent> l, Object r) {
    for (JComponent c : l) onUpdate(c, r);
    callF(r);
  }

  static public ClassLoader getClassLoader(Object o) {
    return o == null ? null : _getClass(o).getClassLoader();
  }

  static public boolean dirOrZipContainsPath(File location, String subPath) {
    try {
      if (location.isDirectory()) {
        return new File(location, subPath).exists();
      } else if (location.isFile()) {
        return zipFileContains_falseOnError(location, subPath);
      }
      return false;
    } catch (Exception __e) {
      throw rethrow(__e);
    }
  }

  static public File[] listFiles(File dir) {
    File[] files = dir.listFiles();
    return files == null ? new File[0] : files;
  }

  static public File[] listFiles(String dir) {
    return listFiles(new File(dir));
  }

  static public String dropPrefixOrNull(String prefix, String s) {
    return s != null && s.startsWith(prefix) ? s.substring(l(prefix)) : null;
  }

  static public List<String> loadedJigsawModuleNames() {
    var moduleLayer = ModuleLayer.boot();
    var modules = moduleLayer.modules();
    return map(modules, mod -> mod.getName());
  }

  static public List<String> classNamesInJigsawModule(String moduleName) {
    return classNamesInJigsawModule(moduleName, javaHome());
  }

  static public List<String> classNamesInJigsawModule(String moduleName, File javaHome) {
    return classNamesInJarOrDir(jigsawModuleFile(moduleName, javaHome), "classes/");
  }

  static public long clockToSysTimeDiff() {
    return sysNow() - now();
  }

  static public <A extends Container> A addComponents(A c, Collection<? extends Component> components) {
    if (nempty(components)) {
      swing(() -> {
        for (Component comp : components) if (comp != null)
          c.add(comp);
        revalidate(c);
      });
    }
    return c;
  }

  static public <A extends Container> A addComponents(A c, Component... components) {
    return addComponents(c, asList(components));
  }

  static public Object getOptMC(String field) {
    return getOpt(mc(), field);
  }

  static public Object cget(Object c, String field) {
    c = derefRef(c);
    Object o = getOpt(c, field);
    return derefRef(o);
  }

  static public Object cget(String field, Object c) {
    return cget(c, field);
  }

  static public String shortDynamicClassName(Object o) {
    if (o instanceof DynamicObject && ((DynamicObject) o).className != null)
      return ((DynamicObject) o).className;
    return shortClassName(o);
  }

  static public int countLines(String s) {
    return l(toLines(s));
  }

  static public int indent_default = 2;

  static public String indent(int indent) {
    return repeat(' ', indent);
  }

  static public String indent(int indent, String s) {
    return indent(repeat(' ', indent), s);
  }

  static public String indent(String indent, String s) {
    return indent + replace(unnull(s), "\n", "\n" + indent);
  }

  static public String indent(String s) {
    return indent(indent_default, s);
  }

  static public List<String> indent(String indent, List<String> lines) {
    List<String> l = new ArrayList();
    if (lines != null)
      for (String s : lines) l.add(indent + s);
    return l;
  }

  static public Lock appendToFile_lock = lock();

  static public boolean appendToFile_keepOpen = false;

  static public HashMap<String, Writer> appendToFile_writers = new HashMap();

  static public void appendToFile(String path, String s) {
    try {
      Lock __0 = appendToFile_lock;
      lock(__0);
      try {
        mkdirsForFile(new File(path));
        path = getCanonicalPath(path);
        Writer writer = appendToFile_writers.get(path);
        if (writer == null) {
          writer = new BufferedWriter(new OutputStreamWriter(newFileOutputStream(path, true), "UTF-8"));
          if (appendToFile_keepOpen)
            appendToFile_writers.put(path, writer);
        }
        writer.write(s);
        if (!appendToFile_keepOpen)
          writer.close();
      } finally {
        unlock(__0);
      }
    } catch (Exception __e) {
      throw rethrow(__e);
    }
  }

  static public void appendToFile(File path, String s) {
    if (path != null)
      appendToFile(path.getPath(), s);
  }

  static public void cleanMeUp_appendToFile() {
    AutoCloseable __3 = tempCleaningUp();
    try {
      Lock __1 = appendToFile_lock;
      lock(__1);
      try {
        closeAllWriters(values(appendToFile_writers));
        appendToFile_writers.clear();
      } finally {
        unlock(__1);
      }
    } finally {
      _close(__3);
    }
  }

  static public File programFile(String name) {
    return prepareProgramFile(name);
  }

  static public File programFile(String progID, String name) {
    return prepareProgramFile(progID, name);
  }

  static public SimpleDateFormat simpleDateFormat_UTC(String format) {
    SimpleDateFormat sdf = new SimpleDateFormat(format);
    sdf.setTimeZone(TimeZone.getTimeZone("UTC"));
    return sdf;
  }

  static public String formatUTCWithMS_24() {
    return formatUTCWithMS_24(now());
  }

  static public String formatUTCWithMS_24(long time) {
    var sdf = new SimpleDateFormat("HH:mm:ss.SSSS");
    sdf.setTimeZone(TimeZone.getTimeZone("UTC"));
    return sdf.format(time) + " UTC";
  }

  static public String prependIfNempty(String prefix, String s) {
    return empty(s) ? unnull(s) : prefix + s;
  }

  static public <A extends Concept> A registerConcept(A c) {
    return registerConcept(db_mainConcepts(), c);
  }

  static public <A extends Concept> A registerConcept(Concepts cc, A c) {
    {
      if (cc != null)
        cc.register(c);
    }
    return c;
  }

  static public <A extends JComponent> A setToolTipText(final A c, final Object toolTip) {
    if (c == null)
      return null;
    {
      swing(() -> {
        String s = str_nullIfEmpty(toolTip);
        if (neq(s, c.getToolTipText()))
          c.setToolTipText(s);
      });
    }
    return c;
  }

  static public <A extends JComponent> A setToolTipText(Object toolTip, A c) {
    return setToolTipText(c, toolTip);
  }

  static public void setTrayIconToolTip(TrayIcon trayIcon, String toolTip) {
    if (trayIcon != null)
      trayIcon.setToolTip(toolTip);
  }

  static public void addToContainer(Container a, Component... b) {
    if (a == null)
      return;
    {
      swing(() -> {
        for (Component c : unnullForIteration(b)) if (c != null)
          a.add(c);
      });
    }
  }

  static public List<Method> findNonDefaultInterfaceMethods(Class intrface) {
    if (!isInterface(intrface))
      return null;
    List<Method> l = new ArrayList();
    _MethodCache cache = getMethodCache(intrface);
    Class c = intrface;
    do {
      for (Method m : c.getDeclaredMethods()) if (m.getDeclaringClass() != Object.class && !m.isDefault() && !isStaticMethod(m))
        l.add(m);
      c = c.getSuperclass();
    } while (c != null);
    return l;
  }

  static public long done2_always(long startTime, String desc) {
    long time = sysNow() - startTime;
    saveTiming_noPrint(time);
    print(desc + " [" + time + " ms]");
    return time;
  }

  static public long done2_always(String desc, long startTime) {
    return done2_always(startTime, desc);
  }

  static public long done2_always(long startTime) {
    return done2_always(startTime, "");
  }

  static public IF0 runnableToIF0(Runnable r) {
    return r == null ? null : () -> {
      r.run();
      return null;
    };
  }

  static public DynamicObject dynamicObject(String className, Object... x) {
    DynamicObject d = new DynamicObject(className);
    for (int i = 0; i < x.length - 1; i += 2) if (x[i + 1] != null)
      setDyn(d, (String) x[i], x[i + 1]);
    return d;
  }

  static public <A, B> B syncGetOrCreate(Map<A, B> map, A key, Class<? extends B> c) {
    try {
      synchronized (map) {
        return getOrCreate(map, key, c);
      }
    } catch (Exception __e) {
      throw rethrow(__e);
    }
  }

  static public <A, B> B syncGetOrCreate(Map<A, B> map, A key, Object f) {
    synchronized (map) {
      return getOrCreate(map, key, f);
    }
  }

  static public <A, B> B syncGetOrCreate(Class<? extends B> c, Map<A, B> map, A key) {
    return syncGetOrCreate(map, key, c);
  }

  static public <A, B> B syncGetOrCreate(Map<A, B> map, A key, IF0<B> f) {
    synchronized (map) {
      return getOrCreate(map, key, f);
    }
  }

  static public List<String> sortedIgnoreCase(Collection<String> c) {
    List<String> l = cloneList(c);
    Collections.sort(l, caseInsensitiveComparator());
    return l;
  }

  static public double nanosToMicroseconds(double ns) {
    return ns / 1000;
  }

  static public <A> OKOrError<A> OKOrError_ok(A a) {
    return new OKOrError(a);
  }

  static public OKOrError OKOrError_error(Throwable e) {
    return new OKOrError(false, e);
  }

  static public <A extends Concept> Collection<A> findConceptsWhere(Class<A> c, Object... params) {
    return findConceptsWhere(db_mainConcepts(), c, params);
  }

  static public Collection<Concept> findConceptsWhere(String c, Object... params) {
    return findConceptsWhere(db_mainConcepts(), c, params);
  }

  static public <A extends Concept> Collection<A> findConceptsWhere(Concepts concepts, Class<A> c, Object... params) {
    ping();
    params = expandParams(c, params);
    if (concepts.fieldIndices != null)
      for (int i = 0; i < l(params); i += 2) {
        IFieldIndex<A, Object> index = concepts.getFieldIndex(c, (String) params[i]);
        if (index != null) {
          Collection<A> rawList = index.getAll(params[i + 1]);
          params = dropEntryFromParams(params, i);
          if (params == null)
            return rawList;
          List<A> l = new ArrayList();
          for (A x : rawList) if (checkConceptFields(x, params))
            l.add(x);
          return l;
        }
      }
    return filterConcepts(concepts.list(c), params);
  }

  static public Collection<Concept> findConceptsWhere(Concepts concepts, String c, Object... params) {
    return filterConcepts(concepts.list(c), params);
  }

  static public <T> void sort(T[] a, Comparator<? super T> c) {
    if (a != null)
      Arrays.sort(a, c);
  }

  static public <T> void sort(T[] a) {
    if (a != null)
      Arrays.sort(a);
  }

  static public void sort(int[] a) {
    if (a != null)
      Arrays.sort(a);
  }

  static public <T> void sort(List<T> a, Comparator<? super T> c) {
    if (a != null)
      Collections.sort(a, c);
  }

  static public void sort(List a) {
    if (a != null)
      Collections.sort(a);
  }

  static public int cmpAlphanumIC(String a, String b) {
    return cmpAlphaNum(a, b);
  }

  static public long round(double d) {
    return Math.round(d);
  }

  static public String round(String s) {
    return roundBracket(s);
  }

  static public Complex round(Complex c) {
    return new Complex(round(c.re), round(c.im));
  }

  static public boolean infoMessage_alwaysOnTop = true;

  static public double infoMessage_defaultTime = 5.0;

  static public JWindow infoMessage(String text) {
    return infoMessage(text, infoMessage_defaultTime);
  }

  static public JWindow infoMessage(final String text, final double seconds) {
    printHidingCredentials(text);
    return infoMessage_noprint(text, seconds);
  }

  static public JWindow infoMessage_noprint(String text) {
    return infoMessage_noprint(text, infoMessage_defaultTime);
  }

  static public JWindow infoMessage_noprint(final String _text, final double seconds) {
    final String text = hideCredentials(_text);
    if (empty(text))
      return null;
    logQuotedWithDate(infoBoxesLogFile(), text);
    if (isHeadless())
      return null;
    return (JWindow) swingAndWait(new F0<Object>() {

      public Object get() {
        try {
          JWindow window = makeWindow(infoMessage_makePanel(text));
          window.setSize(300, 150);
          moveToTopRightCorner(window);
          if (infoMessage_alwaysOnTop)
            window.setAlwaysOnTop(true);
          if (vmBus_noObjections("shouldShowInfoBox", window, text))
            window.setVisible(true);
          if (seconds != 0)
            disposeWindowAfter(iround(seconds * 1000), window);
          return window;
        } catch (Exception __e) {
          throw rethrow(__e);
        }
      }

      public String toString() {
        return "JWindow window = makeWindow(infoMessage_makePanel(text));\r\n    window.setSize...";
      }
    });
  }

  static public JWindow infoMessage(Throwable e) {
    printStackTrace(e);
    return infoMessage(exceptionToStringShort(e));
  }

  static public Object[] asArray(List l) {
    return toObjectArray(l);
  }

  static public <A> A[] asArray(Class<A> type, List l) {
    return (A[]) l.toArray((Object[]) Array.newInstance(type, l.size()));
  }

  static public void swingAndWait(Runnable r) {
    try {
      if (isAWTThread())
        r.run();
      else
        EventQueue.invokeAndWait(addThreadInfoToRunnable(r));
    } catch (Exception __e) {
      throw rethrow(__e);
    }
  }

  static public Object swingAndWait(final Object f) {
    if (isAWTThread())
      return callF(f);
    else {
      final Var result = new Var();
      swingAndWait(new Runnable() {

        public void run() {
          try {
            result.set(callF(f));
          } catch (Exception __e) {
            throw rethrow(__e);
          }
        }

        public String toString() {
          return "result.set(callF(f));";
        }
      });
      return result.get();
    }
  }

  static public MouseAdapter leftClickMouseAdapter(final Object r) {
    return new MouseAdapter() {

      public void mouseClicked(MouseEvent e) {
        if (e.getButton() == 1)
          pcallF(r, new Pt(e.getPoint()));
      }
    };
  }

  static public MouseAdapter leftClickMouseAdapter_noPt(final Object r) {
    return new MouseAdapter() {

      public void mouseClicked(MouseEvent e) {
        if (e.getButton() == 1)
          pcallF(r);
      }
    };
  }

  static public void setCaretPosition(final JTextComponent c, final int pos) {
    if (c != null) {
      swing(() -> {
        try {
          int _pos = max(0, min(l(c.getText()), pos));
          c.setCaretPosition(_pos);
        } catch (Throwable __e) {
          printStackTrace(__e);
        }
      });
    }
  }

  static public void swingLater(long delay, final Object r) {
    javax.swing.Timer timer = new javax.swing.Timer(toInt(delay), actionListener(wrapAsActivity(r)));
    timer.setRepeats(false);
    timer.start();
  }

  static public void swingLater(Object r) {
    SwingUtilities.invokeLater(toRunnable(r));
  }

  static public void fillJMenu(final JMenu m, Object... x) {
    if (x == null)
      return;
    for (int i = 0; i < l(x); i++) {
      Object o = x[i], y = get(x, i + 1);
      if (o instanceof List)
        fillJMenu(m, asArray((List) o));
      else if (isMenuSeparatorIndicator(o)) {
        if (menuItemCount(m) != 0)
          m.addSeparator();
      } else if (o instanceof LiveValue && ((LiveValue) o).getType() == String.class && isRunnableX(y)) {
        final LiveValue<String> lv = (LiveValue<String>) o;
        final JMenuItem mi = jmenuItem(or2(unCurlyBracket(lv.get()), "..."), y);
        bindLiveValueListenerToComponent(mi, lv, new Runnable() {

          public void run() {
            try {
              String s = lv.get();
              if (isCurlyBracketed(s)) {
                setEnabled(mi, false);
                s = unCurlyBracket(s);
              } else
                setEnabled(mi, true);
              setText(mi, s);
              revalidate(m);
            } catch (Exception __e) {
              throw rethrow(__e);
            }
          }

          public String toString() {
            return "String s = lv!;\r\n        if (isCurlyBracketed(s)) {\r\n          setEnabled(mi,...";
          }
        });
        print("bound live value " + lv + " to menu item " + mi);
        m.add(mi);
        ++i;
      } else if (o instanceof String && isRunnableX(y)) {
        m.add(jmenuItem((String) o, y));
        ++i;
      } else if (o instanceof JMenuItem)
        m.add((JMenuItem) o);
      else if (o instanceof String || o instanceof Action || o instanceof Component)
        call(m, "add", o);
      else if (o == null && y instanceof Runnable)
        ++i;
      else if (o != null)
        print("Unknown menu item: " + o);
    }
  }

  static public void fillJPopupMenu(JPopupMenu m, Object... x) {
    if (x == null)
      return;
    for (int i = 0; i < l(x); i++) {
      Object o = x[i], y = get(x, i + 1);
      if (o instanceof IVF1)
        callF(o, m);
      else if (o instanceof List)
        fillJPopupMenu(m, asArray((List) o));
      else if (isMenuSeparatorIndicator(o))
        m.addSeparator();
      else if (o instanceof LiveValue && ((LiveValue) o).getType() == String.class && isRunnableX(y)) {
        final LiveValue<String> lv = (LiveValue<String>) o;
        final JMenuItem mi = jmenuItem("", y);
        bindLiveValueListenerToComponent(mi, lv, new Runnable() {

          public void run() {
            try {
              String s = lv.get();
              if (isCurlyBracketed(s)) {
                setEnabled(mi, false);
                s = unCurlyBracket(s);
              } else
                setEnabled(mi, true);
              setText(mi, s);
            } catch (Exception __e) {
              throw rethrow(__e);
            }
          }

          public String toString() {
            return "String s = lv!;\r\n        if (isCurlyBracketed(s)) {\r\n          setEnabled(mi,...";
          }
        });
        m.add(mi);
      } else if (o instanceof String && isRunnableX(y)) {
        m.add(jmenuItem((String) o, y));
        ++i;
      } else if (o instanceof JMenuItem)
        m.add((JMenuItem) o);
      else if (o instanceof String || o instanceof Action || o instanceof Component)
        call(m, "add", o);
      else if (o != null)
        print("Unknown menu item: " + o);
    }
  }

  static public JTextArea showWrappedText(final String title, final String text) {
    return (JTextArea) swingAndWait(new F0<Object>() {

      public Object get() {
        try {
          JTextArea textArea = wrappedTextArea(text);
          caretToHome(textArea);
          textArea.setFont(typeWriterFont());
          makeFrame(title, new JScrollPane(textArea));
          return textArea;
        } catch (Exception __e) {
          throw rethrow(__e);
        }
      }

      public String toString() {
        return "JTextArea textArea = wrappedTextArea(text);\r\n    caretToHome(textArea);\r\n    ...";
      }
    });
  }

  static public JTextArea showWrappedText(Object text) {
    return showWrappedText(autoFrameTitle(), str(text));
  }

  static public <A extends Component> A toComponent(A c) {
    return c;
  }

  static public Component toComponent(Swingable c) {
    return c == null ? null : c.visualize();
  }

  static public JPanel centerAndEastWithMarginInbetween(Component c, final Component e) {
    return centerAndEast(c, withLeftMargin(e));
  }

  static public JScrollPane borderlessScrollPane(JScrollPane sp) {
    return setBorder(null, withoutViewportBorder(sp));
  }

  static public JScrollPane jHigherScrollPane(final JComponent c) {
    return swing(new F0<JScrollPane>() {

      public JScrollPane get() {
        try {
          return new JScrollPane(c) {

            public Dimension getPreferredSize() {
              Component view = getViewport().getView();
              if (view == null)
                return super.getPreferredSize();
              int pref_width = view.getPreferredSize().width;
              setHorizontalScrollBarPolicy(JScrollPane.HORIZONTAL_SCROLLBAR_ALWAYS);
              Dimension dim = new Dimension(pref_width, super.getPreferredSize().height + getHorizontalScrollBar().getSize().height);
              setHorizontalScrollBarPolicy(JScrollPane.HORIZONTAL_SCROLLBAR_AS_NEEDED);
              return dim;
            }
          };
        } catch (Exception __e) {
          throw rethrow(__e);
        }
      }

      public String toString() {
        return "ret new JScrollPane(c) {\r\n    public Dimension getPreferredSize() {\r\n      Co...";
      }
    });
  }

  static public JPanel jFullCenter(final Component c) {
    return swing(new F0<JPanel>() {

      public JPanel get() {
        try {
          JPanel panel = new JPanel(new GridBagLayout());
          panel.add(c);
          return panel;
        } catch (Exception __e) {
          throw rethrow(__e);
        }
      }

      public String toString() {
        return "JPanel panel = new JPanel(new GridBagLayout);\r\n    panel.add(c);\r\n    ret panel;";
      }
    });
  }

  static public <A extends IMeta> A setMetaSrc(A a, Object src) {
    setMetaAndVerify(a, "src", src);
    return a;
  }

  static public <A> A setMetaSrc(A a, Object src) {
    setMetaAndVerify(a, "src", src);
    return a;
  }

  static public <A extends JComponent> A onFirstShow(A component, Runnable onShow) {
    return onFirstComponentShow(component, onShow);
  }

  static public <A extends JComponent> A onFirstShow(Runnable onShow, A component) {
    return onFirstShow(component, onShow);
  }

  static public void clearTextComponentUndoList(JTextComponent c) {
    swing(() -> {
      if (c instanceof RSyntaxTextArea) {
        ((RSyntaxTextArea) c).discardAllEdits();
        return;
      }
      UndoManager undo = (UndoManager) (metaGet(c, "UndoManager"));
      if (undo != null)
        undo.discardAllEdits();
    });
  }

  static public <A extends JTextComponent> A bindTextComponentToLiveValue_bothWays(A tc, SimpleLiveValue<String> lv) {
    bindLiveValueListenerToComponent(tc, lv, new Runnable() {

      public void run() {
        try {
          setTextKeepCaret(tc, lv.get());
        } catch (Exception __e) {
          throw rethrow(__e);
        }
      }

      public String toString() {
        return "setTextKeepCaret(tc, lv!)";
      }
    });
    onChange(tc, new Runnable() {

      public void run() {
        try {
          lv.set(getText(tc));
        } catch (Exception __e) {
          throw rethrow(__e);
        }
      }

      public String toString() {
        return "lv.set(getText(tc))";
      }
    });
    return tc;
  }

  static public void addKeyListener(final Component c, final KeyListener l) {
    if (c != null) {
      swing(() -> {
        c.addKeyListener(l);
      });
    }
  }

  static public KeyListener ctrlEnterKeyListener(final Object action) {
    final Object info = _threadInfo();
    return new KeyAdapter() {

      public void keyReleased(KeyEvent ke) {
        if (ke.getKeyCode() == KeyEvent.VK_ENTER && ke.getModifiers() == KeyEvent.CTRL_MASK) {
          _threadInheritInfo(info);
          pcallF(action);
        }
      }
    };
  }

  static public SingleThread awtCalcRegularly(JComponent component, int delay, int firstDelay, Object runnable) {
    final SingleThread thread = new SingleThread();
    final Runnable r2 = addThreadInfoToRunnable(runnable);
    final Object info = _threadInfo();
    installTimer(component, delay, firstDelay, new Runnable() {

      public void run() {
        if (!licensed())
          return;
        _threadInheritInfo(info);
        thread.go(r2);
      }
    });
    return thread;
  }

  static public SingleThread awtCalcRegularly(JFrame frame, int delay, int firstDelay, final Object runnable) {
    return awtCalcRegularly(getRootPane(frame), delay, firstDelay, runnable);
  }

  static public int toMS_int(double seconds) {
    return toInt_checked((long) (seconds * 1000));
  }

  static public JComponent wrap(Object swingable) {
    return _recordNewSwingComponent(wrap_2(swingable));
  }

  static public JComponent wrap_2(Object swingable) {
    if (swingable == null)
      return null;
    JComponent c;
    if (swingable instanceof Component)
      c = componentToJComponent((Component) swingable);
    else if (swingable instanceof Swingable)
      c = componentToJComponent(((Swingable) swingable).visualize());
    else
      c = componentToJComponent((Component) callOpt(swingable, "swing"));
    if (c instanceof JTable || c instanceof JList || c instanceof JTextArea || c instanceof JEditorPane || c instanceof JTextPane || c instanceof JTree)
      return jscroll(c);
    return c == null ? jlabel(str(swingable)) : c;
  }

  static public JPanel jSection(Component c) {
    return jSection("", c);
  }

  static public JPanel jSection(final String title, final Component c) {
    return swing(new F0<JPanel>() {

      public JPanel get() {
        try {
          Border border = BorderFactory.createBevelBorder(BevelBorder.LOWERED);
          border = BorderFactory.createTitledBorder(border, title);
          JSection panel = new JSection(c);
          panel.setBorder(border);
          return panel;
        } catch (Exception __e) {
          throw rethrow(__e);
        }
      }

      public String toString() {
        return "Border border = BorderFactory.createBevelBorder(BevelBorder.LOWERED);\r\n    bo...";
      }
    });
  }

  static public JPanel jSection(String title) {
    return jSection(title, jpanel());
  }

  static public JPanel jSection(LiveValue<?> lv, Component c) {
    return jLiveValueSection(lv, c);
  }

  static public boolean newButton_autoToolTip = true;

  static public JButton newButton(final String text, final Object action) {
    return swing(new F0<JButton>() {

      public JButton get() {
        try {
          String text2 = dropPrefix("[disabled] ", text);
          JButton btn = basicJButton(text2);
          if (l(text2) < l(text))
            btn.setEnabled(false);
          if (newButton_autoToolTip) {
            btn.setToolTipText(btn.getText());
          }
          if (action != null)
            btn.addActionListener(actionListener(action, btn));
          return btn;
        } catch (Exception __e) {
          throw rethrow(__e);
        }
      }

      public String toString() {
        return "S text2 = dropPrefix(\"[disabled] \", text);\r\n    JButton btn = basicJButton(te...";
      }
    });
  }

  static public <A> A swingNu(final Class<A> c, final Object... args) {
    return swingConstruct(c, args);
  }

  static public int defaultMargin() {
    return withMargin_defaultWidth;
  }

  static public JPanel marginPanel() {
    return jtransparent(borderLayoutPanel());
  }

  static public boolean isComponentShowing(final Component c) {
    return c != null && swing(new F0<Boolean>() {

      public Boolean get() {
        try {
          return c.isShowing();
        } catch (Exception __e) {
          throw rethrow(__e);
        }
      }

      public String toString() {
        return "return c.isShowing();";
      }
    });
  }

  static public boolean isInQ(Q q) {
    return q != null && isCurrentThread(q.rst.thread);
  }

  static public CharSequence subCharSequence(CharSequence s, int x) {
    return subCharSequence(s, x, s == null ? 0 : s.length());
  }

  static public CharSequence subCharSequence(CharSequence s, int x, int y) {
    if (s == null)
      return null;
    if (x < 0)
      x = 0;
    if (x >= s.length())
      return "";
    if (y < x)
      y = x;
    if (y > s.length())
      y = s.length();
    return s.subSequence(x, y);
  }

  static public String baseClassName(String className) {
    return substring(className, className.lastIndexOf('.') + 1);
  }

  static public String baseClassName(Object o) {
    return baseClassName(getClassName(o));
  }

  static public JComponent jSmallErrorView(Throwable e) {
    var btn = jimageButtonScaledToWidth(32, errorIconID(), "Show error details", () -> showErrorFrame(e));
    var label = jlabel_noAutoToolTip(exceptionType(e));
    return jline(btn, label);
  }

  static public Throwable getInnerException(Throwable e) {
    if (e == null)
      return null;
    while (e.getCause() != null) e = e.getCause();
    return e;
  }

  static public Throwable getInnerException(Runnable r) {
    return getInnerException(getException(r));
  }

  static public <A extends Component> A activateFrameAndReturnComponent(A c) {
    activateFrame(c);
    return c;
  }

  static public <A> A setFrameTitle(A c, final String title) {
    final Frame f = getAWTFrame(c);
    if (f != null) {
      swing(() -> {
        f.setTitle(title);
      });
    }
    return c;
  }

  static public <A extends Component> A setFrameTitle(String title, A c) {
    return setFrameTitle(c, title);
  }

  static public JFrame setFrameTitle(String title) {
    Object f = getOpt(mc(), "frame");
    if (f instanceof JFrame)
      return setFrameTitle((JFrame) f, title);
    return null;
  }

  static public JTextArea newTypeWriterTextArea() {
    return newTypeWriterTextArea("");
  }

  static public JTextArea newTypeWriterTextArea(String text) {
    return withTypeWriterFont(jTextArea(text));
  }

  static public String makeFrame_defaultIcon;

  static public boolean makeFrame_hideConsole = false;

  static public ThreadLocal<VF1<JFrame>> makeFrame_post = new ThreadLocal();

  static public JFrame makeFrame() {
    return makeFrame((Component) null);
  }

  static public JFrame makeFrame(Object content) {
    return makeFrame(programTitle(), content);
  }

  static public JFrame makeFrame(String title) {
    return makeFrame(title, null);
  }

  static public JFrame makeFrame(String title, Object content) {
    return makeFrame(title, content, true);
  }

  static public JFrame makeFrame(final String title, final Object content, final boolean showIt) {
    final VF1<JFrame> post = optParam(makeFrame_post);
    return swing(new F0<JFrame>() {

      public JFrame get() {
        try {
          if (getFrame(content) != null)
            return getFrame(setFrameTitle((Component) content, title));
          final JFrame frame = new JFrame(title);
          if (makeFrame_defaultIcon != null)
            setFrameIconLater(frame, makeFrame_defaultIcon);
          _initFrame(frame);
          Component wrapped = wrap(content);
          if (wrapped != null)
            frame.getContentPane().add(wrapped);
          frame.setBounds(defaultNewFrameBounds());
          callF(post, frame);
          if (showIt)
            frame.setVisible(true);
          if (showIt && makeFrame_hideConsole) {
            hideConsole();
            makeFrame_hideConsole = false;
          }
          return frame;
        } catch (Exception __e) {
          throw rethrow(__e);
        }
      }

      public String toString() {
        return "if (getFrame(content) != null)\r\n      ret getFrame(setFrameTitle((Component) ...";
      }
    });
  }

  static public String autoFrameTitle_value;

  static public String autoFrameTitle() {
    return autoFrameTitle_value != null ? autoFrameTitle_value : getProgramTitle();
  }

  static public void autoFrameTitle(Component c) {
    setFrameTitle(getFrame(c), autoFrameTitle());
  }

  static public String hijackPrint(Runnable r) {
    StringBuilder buf = new StringBuilder();
    Object old = interceptPrintInThisThread(new F1<String, Boolean>() {

      public Boolean get(String s) {
        buf.append(s);
        return false;
      }
    });
    try {
      {
        if (r != null)
          r.run();
      }
      return str(buf);
    } finally {
      interceptPrintInThisThread(old);
    }
  }

  static public <A, B> Map<A, List<B>> multiMapToMap(MultiMap<A, B> m) {
    return m == null ? null : m.data;
  }

  static public <B> TreeMap<String, B> asCIMap(Map<String, B> map) {
    return asCaseInsensitiveMap(map);
  }

  static public int inc(AtomicInteger i) {
    return incAtomicInt(i);
  }

  static public int inc(AtomicInteger i, int delta) {
    return incAtomicInt(i, delta);
  }

  static public long inc(AtomicLong l) {
    return incAtomicLong(l);
  }

  static public long inc(AtomicLong l, long b) {
    return l.addAndGet(b);
  }

  static public int inc(IntVar v) {
    synchronized (v) {
      int val = v.get() + 1;
      v.set(val);
      return val;
    }
  }

  static public int inc(int i) {
    return i + 1;
  }

  static public long inc(long l) {
    return l + 1;
  }

  static public String tabToSingleSpace(String s) {
    return replace(s, '\t', ' ');
  }

  static public void readLocally(String progID, String varNames) {
    readLocally2(mc(), progID, varNames);
  }

  static public void readLocally(String varNames) {
    readLocally2(mc(), programID(), varNames);
  }

  static public void readLocally2(Object obj, String varNames) {
    readLocally2(obj, programID(), varNames);
  }

  static public int readLocally_stringLength;

  static public ThreadLocal<Boolean> readLocally2_allDynamic = new ThreadLocal();

  static public ThreadLocal readLocally2_classFinder = new ThreadLocal();

  static public void readLocally2(Object obj, String progID, String varNames) {
    try {
      boolean allDynamic = isTrue(getAndClearThreadLocal(readLocally2_allDynamic));
      for (String variableName : javaTokC(varNames)) {
        File textFile = new File(programDir(progID), variableName + ".text");
        String value = loadTextFile(textFile);
        if (value != null)
          set(main.class, variableName, value);
        else {
          File structureFile = new File(programDir(progID), variableName + ".structure");
          value = loadTextFile(structureFile);
          if (value == null) {
            File structureGZFile = new File(programDir(progID), variableName + ".structure.gz");
            if (!structureGZFile.isFile())
              return;
            InputStream fis = new FileInputStream(structureGZFile);
            try {
              GZIPInputStream gis = newGZIPInputStream(fis);
              InputStreamReader reader = new InputStreamReader(gis, "UTF-8");
              BufferedReader bufferedReader = new BufferedReader(reader);
              Object o = unstructure_tok(javaTokC_noMLS_onReader(bufferedReader), allDynamic, readLocally2_classFinder.get());
              readLocally_set(obj, variableName, o);
              return;
            } finally {
              _close(fis);
            }
          }
          readLocally_stringLength = l(value);
          if (nempty(value))
            readLocally_set(obj, variableName, unstructure(value, allDynamic, readLocally2_classFinder.get()));
        }
      }
    } catch (Exception __e) {
      throw rethrow(__e);
    }
  }

  static public void readLocally_set(Object c, String varName, Object value) {
    Object oldValue = get(c, varName);
    if (oldValue instanceof List && !(oldValue instanceof ArrayList) && value != null) {
      value = synchroList((List) value);
    }
    set(c, varName, value);
  }

  static public <A> Set<A> synchroHashSet() {
    return synchronizedSet(new HashSet<A>());
  }

  static public Object sleepQuietly_monitor = new Object();

  static public void sleepQuietly() {
    try {
      assertFalse(isAWTThread());
      synchronized (sleepQuietly_monitor) {
        sleepQuietly_monitor.wait();
      }
    } catch (Exception __e) {
      throw rethrow(__e);
    }
  }

  static public String format(String pat, Object... args) {
    return format3(pat, args);
  }

  static public String regexpN2() {
    return "\\d+(?:,\\d+)*";
  }

  static public List<String> regexpLastGroupsIC(String pat, String s) {
    if (s == null)
      return null;
    Matcher m = regexpIC(pat, s);
    List<String> groups = null;
    while (m.find()) groups = regexpGetGroups(m);
    return groups;
  }

  static public int parseIntN2(String s) {
    return parseInt(replace(s, ",", ""));
  }

  static public SimpleDateFormat simpleDateFormat_local(String format) {
    SimpleDateFormat sdf = new SimpleDateFormat(format);
    sdf.setTimeZone(localTimeZone());
    return sdf;
  }

  static public double toMinutes(long ms) {
    return ms / 60000.0;
  }

  static public JPanel smartAdd(JPanel panel, List parts) {
    for (Object o : parts) addToContainer(panel, wrapForSmartAdd(o));
    return panel;
  }

  static public JPanel smartAdd(JPanel panel, Object... parts) {
    return smartAdd(panel, asList(parts));
  }

  static public JPanel westAndCenter(final Component w, final Component c) {
    return swing(new F0<JPanel>() {

      public JPanel get() {
        try {
          JPanel panel = new JPanel(new BorderLayout());
          panel.add(BorderLayout.WEST, wrap(w));
          panel.add(BorderLayout.CENTER, wrap(c));
          return panel;
        } catch (Exception __e) {
          throw rethrow(__e);
        }
      }

      public String toString() {
        return "JPanel panel = new JPanel(new BorderLayout);\r\n    panel.add(BorderLayout.WEST...";
      }
    });
  }

  static public int withRightMargin_defaultWidth = 6;

  static public JPanel withRightMargin(Component c) {
    return withRightMargin(withRightMargin_defaultWidth, c);
  }

  static public JPanel withRightMargin(final int w, final Component c) {
    return swing(new F0<JPanel>() {

      public JPanel get() {
        try {
          JPanel p = marginPanel();
          p.setBorder(BorderFactory.createEmptyBorder(0, 0, 0, w));
          p.add(c);
          return p;
        } catch (Exception __e) {
          throw rethrow(__e);
        }
      }

      public String toString() {
        return "JPanel p = marginPanel();\r\n    p.setBorder(BorderFactory.createEmptyBorder(0,...";
      }
    });
  }

  static public JPanel vstack2(final Object... parts) {
    return swing(new F0<JPanel>() {

      public JPanel get() {
        try {
          JPanel panel = new JPanel(new GridBagLayout());
          GridBagConstraints gbc = new GridBagConstraints();
          gbc.weightx = 1;
          gbc.fill = GridBagConstraints.HORIZONTAL;
          gbc.gridwidth = GridBagConstraints.REMAINDER;
          smartAddWithLayout(panel, gbc, parts);
          gbc.weighty = 1;
          panel.add(jrigid(), gbc);
          return panel;
        } catch (Exception __e) {
          throw rethrow(__e);
        }
      }

      public String toString() {
        return "JPanel panel = new JPanel(new GridBagLayout);\r\n    new GridBagConstraints gbc...";
      }
    });
  }

  static public <A extends JComponent> A instaToolTip(A c, String toolTip) {
    return instaToolTip(toolTip, c);
  }

  static public <A extends JComponent> A instaToolTip(IF0<String> toolTip, A c) {
    new InstantNeverHideToolTip(toolTip, c);
    return c;
  }

  static public <A extends JComponent> A instaToolTip(String toolTip, A c) {
    new InstantNeverHideToolTip(toolTip, c);
    return c;
  }

  static public JLabel jImageLabel(Image img) {
    return swingNu(JLabel.class, imageIcon(img));
  }

  static public JLabel jImageLabel(javax.swing.Icon icon) {
    return swingNu(JLabel.class, icon);
  }

  static public JLabel jImageLabel(String imageID) {
    return jImageLabel(imageIcon(imageID));
  }

  static public JLabel jImageLabel(String text, String imageID) {
    final JLabel l = swingNu(JLabel.class, text, imageIcon(imageID), JLabel.CENTER);
    {
      swing(() -> {
        l.setVerticalTextPosition(SwingConstants.BOTTOM);
        l.setHorizontalTextPosition(SwingConstants.CENTER);
      });
    }
    return l;
  }

  static public String collapseWord(String s) {
    if (s == null)
      return "";
    StringBuilder buf = new StringBuilder();
    for (int i = 0; i < l(s); i++) if (i == 0 || !charactersEqualIC(s.charAt(i), s.charAt(i - 1)))
      buf.append(s.charAt(i));
    return buf.toString();
  }

  static public JPanel northAndCenter(Component n, Component c) {
    return centerAndNorth(c, n);
  }

  static public int withBottomMargin_defaultWidth = 6;

  static public JPanel withBottomMargin(Component c) {
    return withBottomMargin(withBottomMargin_defaultWidth, c);
  }

  static public JPanel withBottomMargin(final int w, final Component c) {
    return swing(new F0<JPanel>() {

      public JPanel get() {
        try {
          JPanel p = new JPanel(new BorderLayout());
          p.setBorder(BorderFactory.createEmptyBorder(0, 0, w, 0));
          p.add(c);
          return p;
        } catch (Exception __e) {
          throw rethrow(__e);
        }
      }

      public String toString() {
        return "JPanel p = new JPanel(new BorderLayout);\r\n    p.setBorder(BorderFactory.creat...";
      }
    });
  }

  static public JLabel jLiveValueLabel(IF0WithChangeListeners var) {
    return jVarLabel(var);
  }

  static public JLabel jVarLabel(IF0WithChangeListeners var) {
    return bindJLabelToVar(jlabel(), var);
  }

  static public JSplitPane setSplitPaneOnFirstShowing(Component c, double value) {
    return setSplitPaneOnFirstShowing(c, value, 0);
  }

  static public JSplitPane setSplitPaneOnFirstShowing(Component c, double value, int delay) {
    final JSplitPane sp = first(childrenOfType(c, JSplitPane.class));
    if (sp != null)
      onFirstResize(sp, new Runnable() {

        public void run() {
          try {
            if (delay == 0)
              sp.setDividerLocation(value);
            else
              awtLater(delay, new Runnable() {

                public void run() {
                  try {
                    sp.setDividerLocation(value);
                  } catch (Exception __e) {
                    throw rethrow(__e);
                  }
                }

                public String toString() {
                  return "sp.setDividerLocation(value);";
                }
              });
          } catch (Exception __e) {
            throw rethrow(__e);
          }
        }

        public String toString() {
          return "ifdef setSplitPaneOnFirstShowing_debug\r\n        printVars setSplitPaneOnFirst...";
        }
      });
    return sp;
  }

  static public String regexpReplace(String s, String pat, IF1<Matcher, String> f) {
    return regexReplace(s, pat, f);
  }

  static public String regexpReplace(String s, String pat, String replacement) {
    return regexpReplace_direct(s, pat, replacement);
  }

  static public String concatMap_strings(Object f, Iterable l) {
    return join((List<String>) map(f, l));
  }

  static public String concatMap_strings(Object f, Object[] l) {
    return join((List<String>) map(f, l));
  }

  static public String concatMap_strings(Iterable l, Object f) {
    return concatMap_strings(f, l);
  }

  static public <A> String concatMap_strings(Iterable<A> l, IF1<A, String> f) {
    return concatMap_strings(f, l);
  }

  static public <A> String concatMap_strings(IF1<A, String> f, Iterable<A> l) {
    return concatMap_strings((Object) f, l);
  }

  static public <A> String concatMap_strings(IF1<A, String> f, A[] l) {
    return concatMap_strings((Object) f, l);
  }

  static public String optionalCurlyBrace(String s) {
    return isCurlyBraced(s) ? s : curlyBrace(s);
  }

  static public String joinWithEmptyLines(Iterable<String> l) {
    return join("\n\n", map(__78 -> rtrim(__78), l));
  }

  static public String joinWithEmptyLines(String... l) {
    return joinWithEmptyLines(asList(l));
  }

  static public List<String> nempties(Collection<String> c) {
    return filterNempty(c);
  }

  static public String rtrim_fromLines(Collection lines) {
    StringBuilder buf = new StringBuilder();
    if (lines != null) {
      boolean first = true;
      for (Object line : lines) {
        if (first)
          first = false;
        else
          buf.append('\n');
        buf.append(str(line));
      }
    }
    return buf.toString();
  }

  static public List<Integer> countIteratorToList_inclusive(int b) {
    return countIteratorToList_inclusive(0, b);
  }

  static public List<Integer> countIteratorToList_inclusive(int a, int b) {
    return asList(countIterator_inclusive(a, b));
  }

  static public <A> List<A> countIteratorToList_inclusive(int b, IF1<Integer, A> f) {
    return countIteratorToList_inclusive(0, b, f);
  }

  static public <A> List<A> countIteratorToList_inclusive(int a, int b, IF1<Integer, A> f) {
    return asList(countIterator_inclusive(a, b, f));
  }

  static public List<Integer> countIteratorToList_inclusive(int a, int b, int step) {
    return asList(countIterator_inclusive_step(a, b, step));
  }

  static public <A> List<A> countIteratorToList_inclusive(double a, double b, double step, IF1<Double, A> f) {
    return asList(countIterator_inclusive(a, b, step, f));
  }

  static public <A> List<Double> countIteratorToList_inclusive(double a, double b, double step) {
    return asList(countIterator_inclusive_step(a, b, step));
  }

  static public <A> List<A> countIteratorToList_inclusive(IF1<Double, A> f, double a, double b, double step) {
    return asList(countIterator_inclusive_step(a, b, step, f));
  }

  static public <A> List<A> countIteratorToList_inclusive(IF1<Integer, A> f, int a, int b) {
    return countIteratorToList_inclusive(f, a, b, 1);
  }

  static public <A> List<A> countIteratorToList_inclusive(IF1<Integer, A> f, int a, int b, int step) {
    return asList(countIterator_inclusive(a, b, step, f));
  }

  static public boolean loadBufferedImage_useImageCache = true;

  static public BufferedImage loadBufferedImage(String snippetIDOrURLOrFile) {
    try {
      ping();
      if (snippetIDOrURLOrFile == null)
        return null;
      if (isURL(snippetIDOrURLOrFile))
        return imageIO_readURL(snippetIDOrURLOrFile);
      if (isSnippetID(snippetIDOrURLOrFile)) {
        String snippetID = "" + parseSnippetID(snippetIDOrURLOrFile);
        IResourceLoader rl = vm_getResourceLoader();
        if (rl != null)
          return loadBufferedImage(rl.loadLibrary(snippetID));
        File dir = imageSnippetsCacheDir();
        if (loadBufferedImage_useImageCache) {
          dir.mkdirs();
          File file = new File(dir, snippetID + ".png");
          if (file.exists() && file.length() != 0)
            try {
              return ImageIO.read(file);
            } catch (Throwable e) {
              e.printStackTrace();
            }
        }
        String imageURL = snippetImageURL_http(snippetID);
        print("Loading image: " + imageURL);
        BufferedImage image = imageIO_readURL(imageURL);
        if (loadBufferedImage_useImageCache) {
          File tempFile = new File(dir, snippetID + ".tmp." + System.currentTimeMillis());
          ImageIO.write(image, "png", tempFile);
          tempFile.renameTo(new File(dir, snippetID + ".png"));
        }
        return image;
      } else
        return loadBufferedImage(new File(snippetIDOrURLOrFile));
    } catch (Exception __e) {
      throw rethrow(__e);
    }
  }

  static public BufferedImage loadBufferedImage(File file) {
    return loadBufferedImageFile(file);
  }

  static public String charToString(char c) {
    return String.valueOf(c);
  }

  static public String charToString(int c) {
    return String.valueOf((char) c);
  }

  static public JTextField onEnter(JTextField tf, JButton btn) {
    if (btn != null)
      onEnter(tf, new Runnable() {

        public void run() {
          try {
            clickButton(btn);
          } catch (Exception __e) {
            throw rethrow(__e);
          }
        }

        public String toString() {
          return "clickButton(btn)";
        }
      });
    return tf;
  }

  static public JTextField onEnter(JTextField tf, Object action) {
    if (action == null || tf == null)
      return tf;
    tf.addActionListener(new java.awt.event.ActionListener() {

      public void actionPerformed(java.awt.event.ActionEvent _evt) {
        try {
          tf.selectAll();
          callF(action);
        } catch (Throwable __e) {
          messageBox(__e);
        }
      }
    });
    return tf;
  }

  static public JButton onEnter(JButton btn, final Object action) {
    if (action == null || btn == null)
      return btn;
    btn.addActionListener(actionListener(action));
    return btn;
  }

  static public JList onEnter(JList list, Object action) {
    list.addKeyListener(enterKeyListener(rCallOnSelectedListItem(list, action)));
    return list;
  }

  static public JComboBox onEnter(final JComboBox cb, Runnable action) {
    {
      swing(() -> {
        if (cb.isEditable()) {
          JTextField text = (JTextField) cb.getEditor().getEditorComponent();
          onEnter(text, action);
        } else {
          cb.getInputMap().put(KeyStroke.getKeyStroke("ENTER"), "enter");
          cb.getActionMap().put("enter", abstractAction("", new Runnable() {

            public void run() {
              try {
                cb.hidePopup();
                callF(action);
              } catch (Exception __e) {
                throw rethrow(__e);
              }
            }

            public String toString() {
              return "cb.hidePopup(); callF(action);";
            }
          }));
        }
      });
    }
    return cb;
  }

  static public JTable onEnter(final JTable table, final Object action) {
    table.getInputMap(JComponent.WHEN_ANCESTOR_OF_FOCUSED_COMPONENT).put(KeyStroke.getKeyStroke(KeyEvent.VK_ENTER, 0), "Enter");
    table.getActionMap().put("Enter", new AbstractAction() {

      public void actionPerformed(ActionEvent e) {
        callF(action, table.getSelectedRow());
      }
    });
    return table;
  }

  static public JTextField onEnter(Runnable action, JTextField tf) {
    return onEnter(tf, action);
  }

  static public ActionListener actionListener(final Object runnable) {
    return actionListener(runnable, null);
  }

  static public ActionListener actionListener(final Object runnable, final Object instanceToHold) {
    if (runnable instanceof ActionListener)
      return (ActionListener) runnable;
    final Object info = _threadInfo();
    return new java.awt.event.ActionListener() {

      public void actionPerformed(java.awt.event.ActionEvent _evt) {
        try {
          _threadInheritInfo(info);
          AutoCloseable __1 = holdInstance(instanceToHold);
          try {
            pcallF(runnable);
          } finally {
            _close(__1);
          }
        } catch (Throwable __e) {
          messageBox(__e);
        }
      }
    };
  }

  static public Object swingCall(final Object o, final String method, final Object... args) {
    return swing(new F0<Object>() {

      public Object get() {
        try {
          return call(o, method, args);
        } catch (Exception __e) {
          throw rethrow(__e);
        }
      }

      public String toString() {
        return "return call(o, method, args);";
      }
    });
  }

  static public int preferredWidth(Component c) {
    return c == null ? 0 : getPreferredSize(c).width;
  }

  static public boolean initSyntaxTextArea_numPadFix = true;

  static public void initSyntaxTextArea(RSyntaxTextArea textArea) {
    swing(() -> {
      if (initSyntaxTextArea_numPadFix)
        new NumPadFixingInputMap().replaceOn(textArea);
      textArea.setSyntaxEditingStyle(SyntaxConstants.SYNTAX_STYLE_JAVA);
      textArea.setHighlightCurrentLine(false);
      textArea.setTabSize(2);
      textArea.setTabsEmulated(true);
      textArea.setCodeFoldingEnabled(false);
      textArea.setMarkOccurrences(true);
    });
  }

  static public List<Integer> countIteratorAsList(int b) {
    return countIteratorAsList(0, b);
  }

  static public List<Integer> countIteratorAsList(int a, int b) {
    return countIteratorToList(a, b);
  }

  static public <A> List<A> countIteratorAsList(int b, IF1<Integer, A> f) {
    return countIteratorAsList(0, b, f);
  }

  static public <A> List<A> countIteratorAsList(int a, int b, IF1<Integer, A> f) {
    return countIteratorToList(a, b, f);
  }

  static public List<Integer> countIteratorAsList(int a, int b, int step) {
    return countIteratorToList(a, b, step);
  }

  static public <A> List<A> countIteratorAsList(double a, double b, double step, IF1<Double, A> f) {
    return countIteratorToList(a, b, step, f);
  }

  static public <A> List<Double> countIteratorAsList(double a, double b, double step) {
    return countIteratorToList(a, b, step);
  }

  static public <A> List<A> countIteratorAsList(IF1<Double, A> f, double a, double b, double step) {
    return countIteratorToList(f, a, b, step);
  }

  static public <A> List<A> countIteratorAsList(IF1<Integer, A> f, int b) {
    return countIteratorAsList(f, 0, b);
  }

  static public <A> List<A> countIteratorAsList(IF1<Integer, A> f, int a, int b) {
    return countIteratorToList(f, a, b);
  }

  static public <A> List<A> nonNulls(Iterable<A> l) {
    return withoutNulls(l);
  }

  static public <A> List<A> nonNulls(A[] l) {
    return withoutNulls(l);
  }

  static public <A, B> Map<A, B> nonNulls(Map<A, B> map) {
    return withoutNulls(map);
  }

  static public IterableIterator<Integer> countIterator(int b) {
    return countIterator(0, b);
  }

  static public IterableIterator<Integer> countIterator(int a, int b) {
    return countIterator_exclusive(a, b);
  }

  static public <A> IterableIterator<A> countIterator(int b, IF1<Integer, A> f) {
    return countIterator(0, b, f);
  }

  static public <A> IterableIterator<A> countIterator(int a, int b, IF1<Integer, A> f) {
    return countIterator_exclusive(a, b, f);
  }

  static public IterableIterator<Integer> countIterator(int a, int b, int step) {
    return countIterator_exclusive_step(a, b, step);
  }

  static public <A> IterableIterator<A> countIterator(double a, double b, double step, IF1<Double, A> f) {
    return countIterator_exclusive_step(a, b, step, f);
  }

  static public <A> IterableIterator<Double> countIterator(double a, double b, double step) {
    return countIterator_exclusive_step(a, b, step);
  }

  static public <A> IterableIterator<A> countIterator(IF1<Double, A> f, double a, double b, double step) {
    return countIterator(a, b, step, f);
  }

  static public <A> IterableIterator<A> countIterator(IF1<Integer, A> f, int b) {
    return countIterator(f, 0, b);
  }

  static public <A> IterableIterator<A> countIterator(IF1<Integer, A> f, int a, int b) {
    return countIterator_exclusive(a, b, f);
  }

  static public <A> IterableIterator<Integer> countIterator(List l) {
    return countIterator(l(l));
  }

  static public Window getWindow(Object o) {
    if (!(o instanceof Component))
      return null;
    return swing(() -> {
      Component c = (Component) o;
      while (c != null) {
        if (c instanceof Window)
          return ((Window) c);
        c = c.getParent();
      }
      return null;
    });
  }

  static public void centerWindowWithin(Window w, Rect r) {
    if (w != null) {
      swing(() -> {
        w.setLocation(r.x + (r.w - w.getWidth()) / 2, r.y + (r.h - w.getHeight()) / 2);
      });
    }
  }

  static public Rect screenBounds_safe(int iScreen) {
    return screenBounds(min(iScreen, screenCount() - 1));
  }

  static public int screenNrOfWindow(Window w) {
    if (w == null)
      return -1;
    Rect bounds = boundsAsRect(w);
    return indexOfMax(allScreenBounds(), screen -> area(intersectRects(bounds, screen)));
  }

  static public Object interceptPrintInThisThread(Object f) {
    Object old = print_byThread().get();
    print_byThread().set(f);
    return old;
  }

  static public <A> List<A> syncCloneAndClearList(Collection<A> l) {
    if (l == null)
      return emptyList();
    synchronized (collectionMutex(l)) {
      List<A> l2 = cloneList(l);
      l.clear();
      return l2;
    }
  }

  static public Object pcallFunction(Object f, Object... args) {
    try {
      return callFunction(f, args);
    } catch (Throwable __e) {
      printStackTrace(__e);
    }
    return null;
  }

  static public <A> List<A> newSubListOrSame(List<A> l, int startIndex) {
    return newSubListOrSame(l, startIndex, l(l));
  }

  static public <A> List<A> newSubListOrSame(List<A> l, int startIndex, int endIndex) {
    if (l == null)
      return null;
    int n = l(l);
    startIndex = max(0, startIndex);
    endIndex = min(n, endIndex);
    if (startIndex >= endIndex)
      return ll();
    if (startIndex == 0 && endIndex == n)
      return l;
    return cloneList(l.subList(startIndex, endIndex));
  }

  static public <A> List<A> newSubListOrSame(List<A> l, IntRange r) {
    return newSubListOrSame(l, r.start, r.end);
  }

  static public int[] takeFirstOfIntArray(int[] b, int n) {
    return subIntArray(b, 0, n);
  }

  static public int[] takeFirstOfIntArray(int n, int[] b) {
    return takeFirstOfIntArray(b, n);
  }

  static public short[] takeFirstOfShortArray(short[] b, int n) {
    return subShortArray(b, 0, n);
  }

  static public short[] takeFirstOfShortArray(int n, short[] b) {
    return takeFirstOfShortArray(b, n);
  }

  static public byte[] takeFirstOfByteArray(byte[] b, int n) {
    return subByteArray(b, 0, n);
  }

  static public byte[] takeFirstOfByteArray(int n, byte[] b) {
    return takeFirstOfByteArray(b, n);
  }

  static public double[] takeFirstOfDoubleArray(double[] b, int n) {
    return subDoubleArray(b, 0, n);
  }

  static public double[] takeFirstOfDoubleArray(int n, double[] b) {
    return takeFirstOfDoubleArray(b, n);
  }

  static public <A> List<A> sortedByCalculatedField(Iterable<A> c, Object f) {
    return sortByCalculatedField(c, f);
  }

  static public <A> List<A> sortedByCalculatedField(Object f, Iterable<A> c) {
    return sortedByCalculatedField(c, f);
  }

  static public <A, B> List<A> sortedByCalculatedField(IF1<A, B> f, Iterable<A> c) {
    return sortedByCalculatedField(c, f);
  }

  static public <A, B> List<A> sortedByCalculatedField(Iterable<A> c, IF1<A, B> f) {
    List<A> l = cloneList(c);
    sort(l, new Comparator<A>() {

      public int compare(A a, A b) {
        return stdcompare(f.get(a), f.get(b));
      }
    });
    return l;
  }

  static public List<String> allMethodNames(Object o) {
    Class c = _getClass(o);
    TreeSet<String> names = new TreeSet();
    while (c != null) {
      for (Method m : c.getDeclaredMethods()) names.add(m.getName());
      c = c.getSuperclass();
    }
    return asList(names);
  }

  static public <A> A getFromIterator(Iterator<A> it, int idx) {
    if (idx < 0)
      return null;
    while (true) {
      ping();
      if (!it.hasNext())
        return null;
      else {
        A a = it.next();
        if (idx-- == 0)
          return a;
      }
    }
  }

  static public IterableIterator<String> linesIterator(final String s) {
    return lines_iterator(s);
  }

  static public Map<Class, Set<String>> allFields_cache = weakHashMap();

  static public Set<String> allFields(Object o) {
    if (o == null)
      return emptySet();
    Class _c = _getClass(o);
    Set<String> fields = allFields_cache.get(_c);
    if (fields == null)
      allFields_cache.put(_c, fields = asTreeSet(keys(getOpt_getFieldMap(o))));
    return fields;
  }

  static public int stdHash(Object a, String... fields) {
    if (a == null)
      return 0;
    int hash = getClassName(a).hashCode();
    for (String field : fields) hash = boostHashCombine(hash, hashCode(getOpt(a, field)));
    return hash;
  }

  static public String trim(String s) {
    return s == null ? null : s.trim();
  }

  static public String trim(StringBuilder buf) {
    return buf.toString().trim();
  }

  static public String trim(StringBuffer buf) {
    return buf.toString().trim();
  }

  static public Map<String, String> singular_specials = litmap("children", "child", "images", "image", "chess", "chess");

  static public Set<String> singular_specials2 = litciset("time", "machine", "line", "rule");

  static public String singular(String s) {
    if (s == null)
      return null;
    {
      String __1 = singular_specials.get(s);
      if (!empty(__1))
        return __1;
    }
    if (singular_specials2.contains(dropSuffix("s", afterLastSpace(s))))
      return dropSuffix("s", s);
    if (s.endsWith("ness"))
      return s;
    if (s.endsWith("ges"))
      return dropSuffix("s", s);
    if (endsWith(s, "bases"))
      return dropLast(s);
    s = dropSuffix("es", s);
    s = dropSuffix("s", s);
    return s;
  }

  static public Set<String> getPlural_specials = litciset("sheep", "fish");

  static public String getPlural(String s) {
    if (contains(getPlural_specials, s))
      return s;
    if (ewic(s, "y"))
      return dropSuffixIgnoreCase("y", s) + "ies";
    if (ewicOneOf(s, "ss", "ch"))
      return s + "es";
    if (ewic(s, "s"))
      return s;
    return s + "s";
  }

  static public double nanoSecondsToSeconds(double nanos) {
    return nanos * 1e-9;
  }

  static public <A extends JComponent> A applyDefaultMargin(final A c) {
    if (c != null) {
      swing(() -> {
        c.setBorder(BorderFactory.createEmptyBorder(withMargin_defaultWidth, withMargin_defaultWidth, withMargin_defaultWidth, withMargin_defaultWidth));
      });
    }
    return c;
  }

  static public <A extends JComponent> A applyMargin(int top, int left, int bottom, int right, A c) {
    return addMargin(top, left, bottom, right, c);
  }

  static public <A extends JComponent> A applyMargin(int w, A c) {
    return addMargin(w, c);
  }

  static public Component horizontalStrut(int height) {
    return Box.createHorizontalStrut(height);
  }

  static public <A> A swingConstruct(final Class<A> c, final Object... args) {
    return swing(new F0<A>() {

      public A get() {
        try {
          return nuObject(c, args);
        } catch (Exception __e) {
          throw rethrow(__e);
        }
      }

      public String toString() {
        return "return nuObject(c, args);";
      }
    });
  }

  static public <A extends JLabel> A setHorizontalAlignment(final int pos, final A a) {
    swingCall(a, "setHorizontalAlignment", pos);
    return a;
  }

  static public <A extends AbstractButton> A setHorizontalAlignment(final int pos, final A a) {
    swingCall(a, "setHorizontalAlignment", pos);
    return a;
  }

  static public <A extends JTextField> A setHorizontalAlignment(final int pos, final A a) {
    swingCall(a, "setHorizontalAlignment", pos);
    return a;
  }

  static public JLabel jLabel(String text) {
    return jlabel(text);
  }

  static public JLabel jLabel() {
    return jlabel();
  }

  static public <A extends JLabel> A centerLabel(A l) {
    if (l != null)
      l.setHorizontalAlignment(SwingConstants.CENTER);
    return l;
  }

  static public JLabel jnarrowLabel() {
    return jnarrowLabel(50);
  }

  static public JLabel jnarrowLabel(int width) {
    return jnarrowLabel(width, "");
  }

  static public JLabel jnarrowLabel(String text) {
    return jnarrowLabel(50, text);
  }

  static public JLabel jnarrowLabel(int width, String text) {
    return jMinWidth_pure(width, jlabel(text));
  }

  static public JLabel jnarrowLabel(JLabel lbl) {
    return jnarrowLabel(50, lbl);
  }

  static public JLabel jnarrowLabel(int width, JLabel lbl) {
    return jMinWidth_pure(width, lbl);
  }

  static public JPanel smartAddWithLayout(JPanel panel, Object layout, List parts) {
    for (Object o : parts) panel.add(wrapForSmartAdd(o), layout);
    return panel;
  }

  static public JPanel smartAddWithLayout(JPanel panel, Object layout, Object... parts) {
    return smartAddWithLayout(panel, layout, asList(flattenArray2(parts)));
  }

  static public Component jrigid() {
    return javax.swing.Box.createRigidArea(new Dimension(0, 0));
  }

  static public JScrollPane jscroll_centered(Component c) {
    return c instanceof JScrollPane ? ((JScrollPane) c) : jscroll(jFullCenter(c));
  }

  static public Object[] flattenArray2(Object... a) {
    List l = new ArrayList();
    if (a != null)
      for (Object x : a) if (x instanceof Object[])
        l.addAll(asList((Object[]) x));
      else if (x instanceof Collection)
        l.addAll((Collection) x);
      else
        l.add(x);
    return asObjectArray(l);
  }

  static public Component wrapForSmartAdd(Object o) {
    if (o == null)
      return jpanel();
    if (o instanceof String)
      return jlabel((String) o);
    return wrap(o);
  }

  static public JScrollPane jscroll(Component c) {
    return swing(() -> {
      return c instanceof JScrollPane ? ((JScrollPane) c) : new JScrollPane(c);
    });
  }

  static public JTextArea wrappedTextArea(final JTextArea ta) {
    enableWordWrapForTextArea(ta);
    return ta;
  }

  static public JTextArea wrappedTextArea() {
    return wrappedTextArea(jtextarea());
  }

  static public JTextArea wrappedTextArea(String text) {
    JTextArea ta = wrappedTextArea();
    setText(ta, text);
    return ta;
  }

  static public <A extends JComponent> A withTypeWriterFont(A c) {
    return setFont(c, typeWriterFont());
  }

  static public JTabbedPane fillJTabs(final JTabbedPane tabs, final Object... _x) {
    if (tabs == null)
      return null;
    clearTabs(tabs);
    Object[] x = flattenArray2(_x);
    int idx = 0;
    if (get(x, 0) instanceof Integer) {
      idx = asInt(get(x, 0));
      x = dropFirst(x);
      if (empty(x)) {
        x = arrayrep(null, idx);
        idx = 0;
      }
    }
    int n = 0;
    for (int i = 0; i < l(x); i++) {
      ++n;
      Object o = x[i];
      if (isComponentOrSwingable(o))
        addTab(tabs, "Tab " + n, wrap(o));
      else {
        String toolTip = "";
        if (o instanceof WithToolTip) {
          toolTip = ((WithToolTip) o).toolTip();
          o = ((WithToolTip) o).get();
        }
        String name = str(or(o, "Tab " + n));
        Component c;
        if (isComponentOrSwingable(get(x, i + 1)))
          c = wrap(get(x, ++i));
        else
          c = new JPanel();
        addTabWithToolTip(tabs, name, toolTip, wrap(c));
      }
    }
    if (idx != 0)
      tabs.setSelectedIndex(min(tabs.getTabCount() - 1, idx));
    return tabs;
  }

  static public String decimalFormatEnglish(String format, double d) {
    return decimalFormatEnglish(format).format(d);
  }

  static public java.text.DecimalFormat decimalFormatEnglish(String format) {
    return new java.text.DecimalFormat(format, new java.text.DecimalFormatSymbols(Locale.ENGLISH));
  }

  static public <A> List<A> synchroList() {
    return synchroList(new ArrayList<A>());
  }

  static public <A> List<A> synchroList(List<A> l) {
    return Collections.synchronizedList(l);
  }

  static public Font getFont(JComponent c) {
    return c == null ? null : swing(new F0<Font>() {

      public Font get() {
        try {
          return c.getFont();
        } catch (Exception __e) {
          throw rethrow(__e);
        }
      }

      public String toString() {
        return "return c.getFont();";
      }
    });
  }

  static public int toInt_checked(long l) {
    if (l != (int) l)
      throw fail("Too large for int: " + l);
    return (int) l;
  }

  static public void addMenuItem(JPopupMenu menu, String text, Object action) {
    menu.add(jmenuItem(text, action));
  }

  static public void addMenuItem(JPopupMenu menu, JMenuItem menuItem) {
    if (menu != null && menuItem != null)
      menu.add(menuItem);
  }

  static public void addMenuItem(JMenu menu, String text, Object action) {
    menu.add(jmenuItem(text, action));
  }

  static public void addMenuItem(Menu menu, String text, Object action) {
    menu.add(menuItem(text, action));
  }

  static public void addMenuItem(JMenu menu, JMenuItem menuItem) {
    menu.add(menuItem);
  }

  static public void addMenuItem(JMenuBar menuBar, String text, Runnable action) {
    addMenuItem(menuBar, jmenuItem(text, action));
  }

  static public void addMenuItem(JMenuBar menuBar, JMenuItem menuItem) {
    addDirectMenuItem(menuBar, menuItem);
  }

  static public <A> List<A> asSynchroList(Iterable<A> l) {
    return syncList(cloneList(l));
  }

  static public <A extends Component> A revalidate(final A c) {
    if (c == null || !c.isShowing())
      return c;
    {
      swing(() -> {
        c.revalidate();
        c.repaint();
      });
    }
    return c;
  }

  static public void revalidate(JFrame f) {
    revalidate((Component) f);
  }

  static public void revalidate(JInternalFrame f) {
    revalidate((Component) f);
  }

  static public boolean arraysEqual(Object[] a, Object[] b) {
    if (a.length != b.length)
      return false;
    for (int i = 0; i < a.length; i++) if (neq(a[i], b[i]))
      return false;
    return true;
  }

  static public int hashCode(Object a) {
    return a == null ? 0 : a.hashCode();
  }

  static public int hashCode(long l) {
    return Long.hashCode(l);
  }

  static public int hashCode(double d) {
    return Double.hashCode(d);
  }

  static public TreeMap descTreeMap() {
    return revTreeMap();
  }

  static public <A> A optParam(ThreadLocal<A> tl, A defaultValue) {
    return optPar(tl, defaultValue);
  }

  static public <A> A optParam(ThreadLocal<A> tl) {
    return optPar(tl);
  }

  static public Object optParam(String name, Map params) {
    return mapGet(params, name);
  }

  static public <A> A optParam(Object[] opt, String name, A defaultValue) {
    int n = l(opt);
    if (n == 1 && opt[0] instanceof Map) {
      Map map = (Map) (opt[0]);
      return map.containsKey(name) ? (A) map.get(name) : defaultValue;
    }
    if (!even(l(opt)))
      throw fail("Odd parameter length");
    for (int i = 0; i < l(opt); i += 2) if (eq(opt[i], name))
      return (A) opt[i + 1];
    return defaultValue;
  }

  static public Object optParam(Object[] opt, String name) {
    return optParam(opt, name, null);
  }

  static public Object optParam(String name, Object[] params) {
    return optParam(params, name);
  }

  static public String replacePlusWithSpace(String s) {
    return replace(s, '+', ' ');
  }

  static public List<String> splitAtSpace(String s) {
    return empty(s) ? emptyList() : asList(s.split("\\s+"));
  }

  static public <A, B> A pairA(Pair<A, B> p) {
    return p == null ? null : p.a;
  }

  static public <A, B> B pairB(Pair<A, B> p) {
    return p == null ? null : p.b;
  }

  static public int scoredSearch_score_single(String s, String query) {
    int i = indexOfIC_underscore(s, query);
    if (i < 0)
      return 0;
    if (i > 0)
      return 1;
    return l(s) == l(query) ? 3 : 2;
  }

  static public <A, B> List<B> secondOfPairs(Collection<Pair<A, B>> l) {
    return lambdaMap(__79 -> secondOfPair(__79), l);
  }

  static public int roundToInt(double d) {
    return (int) Math.round(d);
  }

  static public Object iteratorFromFunction_endMarker = new Object();

  static public <A> IterableIterator<A> iteratorFromFunction_withEndMarker(final Object f) {
    class IFF extends IterableIterator<A> {

      public A a;

      public boolean have, done;

      public boolean hasNext() {
        getNext();
        return !done;
      }

      public A next() {
        getNext();
        if (done)
          throw fail();
        A _a = a;
        a = null;
        have = false;
        return _a;
      }

      public void getNext() {
        if (done || have)
          return;
        Object o = callF(f);
        if (o == iteratorFromFunction_endMarker) {
          done = true;
          return;
        }
        a = (A) o;
        have = true;
      }
    }
    ;
    return new IFF();
  }

  static public <A> IterableIterator<A> iteratorFromFunction_withEndMarker(final F0 f) {
    return iteratorFromFunction_withEndMarker_f0(f);
  }

  static public int withMargin_defaultWidth = 6;

  static public JPanel withMargin(Component c) {
    return withMargin(withMargin_defaultWidth, c);
  }

  static public JPanel withMargin(int w, Component c) {
    return withMargin(w, w, c);
  }

  static public JPanel withMargin(int w, int h, Component c) {
    return withMargin(w, h, w, h, c);
  }

  static public JPanel withMargin(final int top, final int left, final int bottom, final int right, final Component c) {
    return swing(new F0<JPanel>() {

      public JPanel get() {
        try {
          JPanel p = marginPanel();
          p.setBorder(BorderFactory.createEmptyBorder(top, left, bottom, right));
          p.add(c);
          return p;
        } catch (Exception __e) {
          throw rethrow(__e);
        }
      }

      public String toString() {
        return "JPanel p = marginPanel();\r\n    p.setBorder(BorderFactory.createEmptyBorder(to...";
      }
    });
  }

  static public String reverseString(String s) {
    return empty(s) ? s : new StringBuilder(s).reverse().toString();
  }

  static public BufferedImage newBufferedImage(int w, int h) {
    return new BufferedImage(w, h, BufferedImage.TYPE_INT_RGB);
  }

  static public BufferedImage newBufferedImage(int w, int h, RGB rgb) {
    return newBufferedImage(w, h, rgb.getColor());
  }

  static public BufferedImage newBufferedImage(int w, int h, Color color) {
    BufferedImage img = newBufferedImage(w, h);
    Graphics2D g = img.createGraphics();
    g.setColor(or(color, Color.white));
    g.fillRect(0, 0, w, h);
    return img;
  }

  static public BufferedImage newBufferedImage(Pt p, Color color) {
    return newBufferedImage(p.x, p.y, color);
  }

  static public BufferedImage newBufferedImage(int w, int h, int[] pixels) {
    return intArrayToBufferedImage(pixels, w, h);
  }

  static public BufferedImage intArrayToBufferedImage(int[] pixels, int w, int h) {
    int[] bitMasks = new int[] { 0xFF0000, 0xFF00, 0xFF, 0xFF000000 };
    SinglePixelPackedSampleModel sm = new SinglePixelPackedSampleModel(DataBuffer.TYPE_INT, w, h, bitMasks);
    DataBufferInt db = new DataBufferInt(pixels, pixels.length);
    WritableRaster wr = Raster.createWritableRaster(sm, db, new Point());
    return new BufferedImageWithMeta(ColorModel.getRGBdefault(), wr, false, null);
  }

  static public Random defaultRandomizer() {
    return defaultRandomGenerator();
  }

  static public int boolToInt(boolean b) {
    return b ? 1 : 0;
  }

  static public boolean isTrueOrYes(Object o) {
    return isTrueOpt(o) || o instanceof String && (eqicOneOf(((String) o), "1", "t", "true") || isYes(((String) o)));
  }

  static public <A, B> LinkedHashMap<A, B> asLinkedHashMap(Map<A, B> map) {
    if (map instanceof LinkedHashMap)
      return (LinkedHashMap) map;
    LinkedHashMap<A, B> m = new LinkedHashMap();
    if (map != null)
      synchronized (collectionMutex(map)) {
        m.putAll(map);
      }
    return m;
  }

  static public Map<Class, Constructor> nuObjectWithoutArguments_cache = newDangerousWeakHashMap();

  static public Object nuObjectWithoutArguments(String className) {
    try {
      return nuObjectWithoutArguments(classForName(className));
    } catch (Exception __e) {
      throw rethrow(__e);
    }
  }

  static public <A> A nuObjectWithoutArguments(Class<A> c) {
    try {
      if (nuObjectWithoutArguments_cache == null)
        return (A) nuObjectWithoutArguments_findConstructor(c).newInstance();
      Constructor m = nuObjectWithoutArguments_cache.get(c);
      if (m == null)
        nuObjectWithoutArguments_cache.put(c, m = nuObjectWithoutArguments_findConstructor(c));
      return (A) m.newInstance();
    } catch (Exception __e) {
      throw rethrow(__e);
    }
  }

  static public Constructor nuObjectWithoutArguments_findConstructor(Class c) {
    for (Constructor m : getDeclaredConstructors_cached(c)) if (empty(m.getParameterTypes())) {
      makeAccessible(m);
      return m;
    }
    throw fail("No default constructor found in " + c.getName());
  }

  static public List<Class> getClasses(Object[] array) {
    List<Class> l = emptyList(l(array));
    for (Object o : array) l.add(_getClass(o));
    return l;
  }

  static public ClassLoader classLoaderForObject(Object o) {
    if (o instanceof ClassLoader)
      return ((ClassLoader) o);
    if (o == null)
      return null;
    return _getClass(o).getClassLoader();
  }

  static public String classNameToVM(String name) {
    return name.replace(".", "$");
  }

  static public <A> List<A> wrapAsList(A[] a) {
    return wrapArrayAsList(a);
  }

  static public IMeta initMetaOfJComponent(JComponent c) {
    if (c == null)
      return null;
    IMeta meta = (IMeta) (c.getClientProperty(IMeta.class));
    if (meta == null)
      c.putClientProperty(IMeta.class, meta = new Meta());
    return meta;
  }

  static public <A> A optCast(Class<A> c, Object o) {
    return isInstance(c, o) ? (A) o : null;
  }

  static public <A> Set<A> synchroLinkedHashSet() {
    return Collections.synchronizedSet(new CompactLinkedHashSet());
  }

  static public int indexOfNonDigit(String s) {
    int n = l(s);
    for (int i = 0; i < n; i++) if (!isDigit(s.charAt(i)))
      return i;
    return -1;
  }

  static public boolean containsNewLines(String s) {
    return containsNewLine(s);
  }

  static public String jlabel_textAsHTML_center(String text) {
    return "<html><div style=\"text-align: center;\">" + replace(htmlencode2(text), "\n", "<br>") + "</div></html>";
  }

  static public String renderVars_str(Object... params) {
    List<String> l = new ArrayList();
    int i = 0;
    if (odd(l(params))) {
      l.add(strOrNull(first(params)));
      ++i;
    }
    for (; i + 1 < l(params); i += 2) l.add(params[i] + "=" + params[i + 1]);
    return trim(joinWithComma(l));
  }

  static public <A> A[] makeArray(Class<A> type, int n) {
    return (A[]) Array.newInstance(type, n);
  }

  static public int lastIndexOf(String a, String b) {
    return a == null || b == null ? -1 : a.lastIndexOf(b);
  }

  static public int lastIndexOf(String a, char b) {
    return a == null ? -1 : a.lastIndexOf(b);
  }

  static public <A> int lastIndexOf(List<A> l, int i, A a) {
    if (l == null)
      return -1;
    for (i = min(l(l), i) - 1; i >= 0; i--) if (eq(l.get(i), a))
      return i;
    return -1;
  }

  static public <A> int lastIndexOf(List<A> l, A a) {
    if (l == null)
      return -1;
    for (int i = l(l) - 1; i >= 0; i--) if (eq(l.get(i), a))
      return i;
    return -1;
  }

  static public int lCommonPrefix(String a, String b) {
    int i = 0, n = Math.min(l(a), l(b));
    while (i < n && a.charAt(i) == b.charAt(i)) ++i;
    return i;
  }

  static public String appendColonIfNempty(String s) {
    return empty(s) ? "" : s + ": ";
  }

  static public void assertFalse(Object o) {
    if (!(eq(o, false)))
      throw fail(str(o));
  }

  static public boolean assertFalse(boolean b) {
    if (b)
      throw fail("oops");
    return b;
  }

  static public boolean assertFalse(String msg, boolean b) {
    if (b)
      throw fail(msg);
    return b;
  }

  static public boolean _inCore() {
    return false;
  }

  static public List hotwire_copyOver_after = synchroList();

  static public void hotwire_copyOver(Class c) {
    for (String field : ll("print_log", "print_silent", "androidContext", "_userHome")) setOptIfNotNull(c, field, getOpt(mc(), field));
    setOptIfNotNull(c, "mainBot", getMainBot());
    setOpt(c, "creator_class", new WeakReference(mc()));
    pcallFAll(hotwire_copyOver_after, c);
  }

  static public String hopeningTag(String tag, Map params) {
    return hopeningTag(tag, mapToParams(params));
  }

  static public String hopeningTag(String tag, Object... params) {
    StringBuilder buf = new StringBuilder();
    buf.append("<" + tag);
    params = unrollParams(params);
    for (int i = 0; i < l(params); i += 2) {
      String name = (String) get(params, i);
      Object val = get(params, i + 1);
      if (nempty(name) && val != null) {
        if (eqOneOf(val, html_valueLessParam(), true))
          buf.append(" " + name);
        else {
          String s = str(val);
          if (!empty(s))
            buf.append(" " + name + "=" + htmlQuote(s));
        }
      }
    }
    buf.append(">");
    return str(buf);
  }

  static public String htag(String tag) {
    return htag(tag, "");
  }

  static public String htag(String tag, Object contents, Object... params) {
    String openingTag = hopeningTag(tag, params);
    String s = str(contents);
    if (empty(s) && neqic(tag, "script"))
      return dropLast(openingTag) + "/>";
    return openingTag + s + "</" + tag + ">";
  }

  static public String joinStrings(String sep, Object... strings) {
    return joinStrings(sep, Arrays.asList(strings));
  }

  static public String joinStrings(String sep, Iterable strings) {
    StringBuilder buf = new StringBuilder();
    for (Object o : unnull(strings)) {
      String s = strOrNull(o);
      if (nempty(s)) {
        if (nempty(buf))
          buf.append(sep);
        buf.append(s);
      }
    }
    return str(buf);
  }

  static public int identityHashCode(Object o) {
    return System.identityHashCode(o);
  }

  static public Random customRandomizerForThisThread() {
    return customRandomizerForThisThread_tl().get();
  }

  static public <A> A listGet(List<A> l, int idx) {
    return l != null && idx >= 0 && idx < l(l) ? l.get(idx) : null;
  }

  static public <A> List<A> newSubList(List<A> l, int startIndex, int endIndex) {
    return cloneList(subList(l, startIndex, endIndex));
  }

  static public <A> List<A> newSubList(List<A> l, int startIndex) {
    return cloneList(subList(l, startIndex));
  }

  static public String formatWithThousandsSeparator(long l) {
    return NumberFormat.getInstance(new Locale("en_US")).format(l);
  }

  static public <A extends Component> A repaint(A c) {
    if (c != null)
      c.repaint();
    return c;
  }

  static public void imageSurface_unpixelated(ImageSurface imageSurface) {
    if (imageSurface == null)
      return;
    imageSurface.interpolationMode = RenderingHints.VALUE_INTERPOLATION_BILINEAR;
    repaint(imageSurface);
  }

  static public boolean sameSnippetID(String a, String b) {
    if (!isSnippetID(a) || !isSnippetID(b))
      return false;
    return parseSnippetID(a) == parseSnippetID(b);
  }

  static public BufferedImage copyImage(Image img) {
    if (img == null)
      return null;
    if (img instanceof BufferedImage)
      return copyImage((BufferedImage) img);
    int w = img.getWidth(null), h = img.getHeight(null);
    BufferedImage bi = newBufferedImage(w, h);
    drawImage(bi, img);
    return bi;
  }

  static public BufferedImage copyImage(BufferedImage bi) {
    if (bi == null)
      return null;
    ColorModel cm = bi.getColorModel();
    boolean isAlphaPremultiplied = cm.isAlphaPremultiplied();
    WritableRaster raster = bi.copyData(bi.getRaster().createCompatibleWritableRaster());
    return new BufferedImage(cm, raster, isAlphaPremultiplied, null);
  }

  static public boolean isEmpty(Collection c) {
    return c == null || c.isEmpty();
  }

  static public boolean isEmpty(CharSequence s) {
    return s == null || s.length() == 0;
  }

  static public boolean isEmpty(Object[] a) {
    return a == null || a.length == 0;
  }

  static public boolean isEmpty(byte[] a) {
    return a == null || a.length == 0;
  }

  static public boolean isEmpty(Map map) {
    return map == null || map.isEmpty();
  }

  static public boolean isEmpty(AppendableChain c) {
    return c == null;
  }

  static public String actualUserHome_value;

  static public String actualUserHome() {
    if (actualUserHome_value == null) {
      if (isAndroid())
        actualUserHome_value = "/storage/emulated/0/";
      else
        actualUserHome_value = System.getProperty("user.home");
    }
    return actualUserHome_value;
  }

  static public File actualUserHome(String sub) {
    return newFile(new File(actualUserHome()), sub);
  }

  static public File userDir() {
    return new File(userHome());
  }

  static public File userDir(String path) {
    return new File(userHome(), path);
  }

  static public void closeRandomAccessFile(RandomAccessFile f) {
    if (f != null)
      try {
        f.close();
        callJavaX("dropIO", f);
      } catch (Throwable e) {
        printStackTrace(e);
      }
  }

  static public RandomAccessFile newRandomAccessFile(File path, String mode) {
    try {
      boolean forWrite = mode.indexOf('w') >= 0;
      if (forWrite)
        mkdirsForFile(path);
      RandomAccessFile f = new RandomAccessFile(path, mode);
      callJavaX("registerIO", f, path, forWrite);
      return f;
    } catch (Exception __e) {
      throw rethrow(__e);
    }
  }

  static public boolean deleteFile(File file) {
    return file != null && file.delete();
  }

  static public CloseableIterableIterator<String> linesFromFile(File f) {
    return linesFromFile(f, null);
  }

  static public CloseableIterableIterator<String> linesFromFile(File f, IResourceHolder resourceHolder) {
    try {
      if (!f.exists())
        return emptyCloseableIterableIterator();
      if (ewic(f.getName(), ".gz"))
        return linesFromReader(utf8bufferedReader(newGZIPInputStream(f)), resourceHolder);
      return linesFromReader(utf8bufferedReader(f), resourceHolder);
    } catch (Exception __e) {
      throw rethrow(__e);
    }
  }

  static public CloseableIterableIterator<String> linesFromFile(String path) {
    return linesFromFile(path, null);
  }

  static public CloseableIterableIterator<String> linesFromFile(String path, IResourceHolder resourceHolder) {
    return linesFromFile(newFile(path), resourceHolder);
  }

  static public String f2s(File f) {
    return f == null ? null : f.getAbsolutePath();
  }

  static public String f2s(String s) {
    return f2s(newFile(s));
  }

  static public String f2s(java.nio.file.Path p) {
    return p == null ? null : f2s(p.toFile());
  }

  static public void copyStream(InputStream in, OutputStream out) {
    try {
      byte[] buf = new byte[65536];
      while (true) {
        int n = in.read(buf);
        if (n <= 0)
          return;
        out.write(buf, 0, n);
      }
    } catch (Exception __e) {
      throw rethrow(__e);
    }
  }

  static public void _registerIO(Object object, String path, boolean opened) {
  }

  static public AutoCloseable tempLock(Lock lock) {
    return tempLock("", lock);
  }

  static public AutoCloseable tempLock(String purpose, Lock lock) {
    if (lock == null)
      return null;
    lock(lock);
    return new AutoCloseable() {

      public String toString() {
        return "unlock(lock);";
      }

      public void close() throws Exception {
        unlock(lock);
      }
    };
  }

  static public String singleFieldName(Class c) {
    Set<String> l = listFields(c);
    if (l(l) != 1)
      throw fail("No single field found in " + c + " (have " + n(l(l), "fields") + ")");
    return first(l);
  }

  static public void warnIfOddCount(Object... list) {
    if (odd(l(list)))
      printStackTrace("Odd list size: " + list);
  }

  static public <A extends Concept> List<A> findBackRefs(Collection<? extends Concept> concepts, Class<A> type) {
    IdentityHashMap<A, Boolean> l = new IdentityHashMap();
    for (Concept c : concepts) if (c.backRefs != null)
      for (Concept.Ref r : c.backRefs) if (instanceOf(r.concept(), type))
        l.put((A) r.concept(), true);
    return asList(keys(l));
  }

  static public <A extends Concept> List<A> findBackRefs(Concept c, Class<A> type) {
    IdentityHashMap<A, Boolean> l = new IdentityHashMap();
    if (c != null && c.backRefs != null)
      for (Concept.Ref r : c.backRefs) if (instanceOf(r.concept(), type))
        l.put((A) r.concept(), true);
    return asList(keys(l));
  }

  static public <A extends Concept> List<A> findBackRefs(Class<A> type, Concept c) {
    return findBackRefs(c, type);
  }

  static public Collection<Concept> findBackRefs(Concept c) {
    return findBackRefs(c, Concept.class);
  }

  static public boolean checkConceptFieldsIC(Concept x, Object... data) {
    for (int i = 0; i < l(data); i += 2) if (!eqicOrEq(cget(x, (String) data[i]), deref(data[i + 1])))
      return false;
    return true;
  }

  static public HashMap<String, Class> findClass_cache = new HashMap();

  static public Class findClass(String name) {
    synchronized (findClass_cache) {
      if (findClass_cache.containsKey(name))
        return findClass_cache.get(name);
      if (!isJavaIdentifier(name))
        return null;
      Class c;
      try {
        c = Class.forName("main$" + name);
      } catch (ClassNotFoundException e) {
        c = null;
      }
      findClass_cache.put(name, c);
      return c;
    }
  }

  static public File getProgramDir() {
    return programDir();
  }

  static public File getProgramDir(String snippetID) {
    return programDir(snippetID);
  }

  static public <A> List<A> sorted(Collection<A> c, Object comparator) {
    List<A> l = cloneList(c);
    sort(l, makeComparator(comparator));
    return l;
  }

  static public <A> List<A> sorted(Collection<A> c) {
    List<A> l = cloneList(c);
    sort(l);
    return l;
  }

  static public <A> List<A> sorted(Comparator<A> comparator, Collection<A> c) {
    List<A> l = cloneList(c);
    sort(l, comparator);
    return l;
  }

  static public List<String> methodsStartingWith(Object o, final String prefix) {
    return filter(allMethodNames(o), new F1<String, Object>() {

      public Object get(String s) {
        try {
          return startsWith(s, prefix);
        } catch (Exception __e) {
          throw rethrow(__e);
        }
      }

      public String toString() {
        return "startsWith(s, prefix)";
      }
    });
  }

  static volatile public PersistableThrowable _handleException_lastException;

  static public List _handleException_onException = synchroList(ll((IVF1<Throwable>) (__1 -> printStackTrace2(__1))));

  static public boolean _handleException_showThreadCancellations = false;

  static public void _handleException(Throwable e) {
    _handleException_lastException = persistableThrowable(e);
    Throwable e2 = innerException(e);
    if (e2.getClass() == RuntimeException.class && eq(e2.getMessage(), "Thread cancelled.") || e2 instanceof InterruptedException) {
      if (_handleException_showThreadCancellations)
        System.out.println(getStackTrace_noRecord(e2));
      return;
    }
    for (Object f : cloneList(_handleException_onException)) try {
      callF(f, e);
    } catch (Throwable e3) {
      try {
        printStackTrace2(e3);
      } catch (Throwable e4) {
        System.out.println(getStackTrace(e3));
        System.out.println(getStackTrace(e4));
      }
    }
  }

  static public boolean interruptThread_verbose = false;

  static public void interruptThread(Thread t) {
    if (t == null)
      return;
    if (interruptThread_verbose)
      print("Interrupting thread " + t);
    vm_threadInterruptionReasonsMap().put(t, getStackTrace());
    t.interrupt();
    URLConnection c = (URLConnection) (vm_generalSubMap("URLConnection per thread").get(t));
    if (c != null) {
      try {
        print("Closing URLConnection of interrupted thread.");
        call(c, "disconnect");
      } catch (Throwable __e) {
        printStackTrace(__e);
      }
    }
  }

  static public boolean isJavaXClassLoader(ClassLoader cl) {
    return startsWithOneOf(className(cl), "main$JavaXClassLoader", "x30$JavaXClassLoader");
  }

  static public void setOptAll(Object o, Map<String, Object> fields) {
    if (fields == null)
      return;
    for (String field : keys(fields)) setOpt(o, field, fields.get(field));
  }

  static public void setOptAll(Object o, Object... values) {
    warnIfOddCount(values);
    for (int i = 0; i + 1 < l(values); i += 2) {
      String field = (String) values[i];
      Object value = values[i + 1];
      setOpt(o, field, value);
    }
  }

  static public boolean checkConceptFields(Concept x, Object... data) {
    for (int i = 0; i < l(data); i += 2) if (neq(cget(x, (String) data[i]), deref(data[i + 1])))
      return false;
    return true;
  }

  static public <A> Set<A> newWeakHashSet() {
    return synchroWeakHashSet();
  }

  static public <A> A getAndClearThreadLocal(ThreadLocal<A> tl) {
    A a = tl.get();
    tl.set(null);
    return a;
  }

  static public <A> AutoCloseable tempSetTL(ThreadLocal<A> tl, A a) {
    return tempSetThreadLocal(tl, a);
  }

  static public <A> AutoCloseable tempSetTL(BetterThreadLocal<A> tl, A a) {
    return tempSetThreadLocalIfNecessary(tl, a);
  }

  static public void printStackTrace_inPossiblyCancelledThread(Throwable e) {
    AutoCloseable __1 = tempUncancelThread();
    try {
      System.out.println(getStackTrace_noRecord(e));
    } finally {
      _close(__1);
    }
  }

  static public List beforeDelegatingToThread_operations = synchroList();

  static public void beforeDelegatingToThread(Thread t) {
    for (Object op : cloneList(beforeDelegatingToThread_operations)) pcallF(op, t);
  }

  static public void beforeDelegatingToThread_do(Object f) {
    setAdd(beforeDelegatingToThread_operations, f);
  }

  static public <A, B> Either<A, B> either2(B b) {
    return new Either(2, b);
  }

  static public <A, B> Either<A, B> either1(A a) {
    return new Either(1, a);
  }

  static public List afterDelegatingToThread_operations = synchroList();

  static public void afterDelegatingToThread(Thread t) {
    for (Object op : cloneList(afterDelegatingToThread_operations)) pcallF(op, t);
  }

  static public void afterDelegatingToThread_do(Object f) {
    setAdd(afterDelegatingToThread_operations, f);
  }

  static public Charset utf8charset_cache;

  static public Charset utf8charset() {
    if (utf8charset_cache == null)
      utf8charset_cache = utf8charset_load();
    return utf8charset_cache;
  }

  static public Charset utf8charset_load() {
    return Charset.forName("UTF-8");
  }

  static public <A> A[] newArray(Class<A> c, int n) {
    return typedArray(c, n);
  }

  static public Object costCenter() {
    return mc();
  }

  static public int typeConversionScoreWithUnboxing(Class a, Class b) {
    int score = typeConversionScore(a, b);
    if (score == 0 || score == 1)
      return score;
    Class aPrim = boxedToPrimitiveType(a);
    if (aPrim != null) {
      int score2 = typeConversionScore(aPrim, b);
      if (score2 == 0)
        return 1;
      else if (score2 != Integer.MAX_VALUE)
        return score2;
    }
    return score;
  }

  static public Object convertPrimitiveIfNecessary(Object o, Class b) {
    if (b.isPrimitive()) {
      if (o instanceof Character) {
        char x = (char) (((Character) o));
        if (b == int.class)
          return Integer.valueOf(x);
        if (b == long.class)
          return Long.valueOf(x);
        if (b == float.class)
          return Float.valueOf(x);
        if (b == double.class)
          return Double.valueOf(x);
      } else if (o instanceof Number) {
        if (b == char.class)
          return Character.valueOf((char) ((Number) o).intValue());
        if (b == short.class)
          return ((Number) o).shortValue();
        if (b == int.class)
          return ((Number) o).intValue();
        if (b == long.class)
          return ((Number) o).longValue();
        if (b == float.class)
          return ((Number) o).floatValue();
      }
    }
    return o;
  }

  static public boolean isIPv4(String s) {
    return s != null && l(javaTokC(s)) == 7 && jfind(javaTok(s), "<int>.<int>.<int>.<int>") == 1;
  }

  static public boolean isSubclassOf(Class a, Class b) {
    return isSubclass(a, b);
  }

  static public <A> A singletonOpt(Collection<A> l) {
    return l(l) == 1 ? first(l) : null;
  }

  static public <A> A singletonOpt(A[] l) {
    return l(l) == 1 ? first(l) : null;
  }

  static public IterableIterator emptyIterableIterator_instance = new IterableIterator() {

    public Object next() {
      throw fail();
    }

    public boolean hasNext() {
      return false;
    }
  };

  static public <A> IterableIterator<A> emptyIterableIterator() {
    return emptyIterableIterator_instance;
  }

  static public DocumentListener runnableToDocumentListener(Runnable r) {
    return new DocumentListener() {

      public void insertUpdate(DocumentEvent e) {
        pcallF(r);
      }

      public void removeUpdate(DocumentEvent e) {
        pcallF(r);
      }

      public void changedUpdate(DocumentEvent e) {
        pcallF(r);
      }
    };
  }

  static public String selectedItem(JList l) {
    return getSelectedItem(l);
  }

  static public String selectedItem(JComboBox cb) {
    return getSelectedItem(cb);
  }

  static public boolean zipFileContains_falseOnError(File inZip, String fileName) {
    try {
      return zipFileContains(inZip, fileName);
    } catch (Throwable e) {
      return false;
    }
  }

  static public File javaHome() {
    return envJavaHome();
  }

  static public File javaHome(String sub) {
    return newFile(envJavaHome(), sub);
  }

  static public File jigsawModuleFile(String moduleName) {
    return jigsawModuleFile(moduleName, javaHome());
  }

  static public File jigsawModuleFile(String moduleName, File javaHome) {
    return new File(javaHome, "jmods/" + moduleName + ".jmod");
  }

  static public Object derefRef(Object o) {
    if (o instanceof Concept.Ref)
      o = ((Concept.Ref) o).get();
    return o;
  }

  static public <A extends Concept> A derefRef(Concept.Ref<A> r) {
    return r == null ? null : r.get();
  }

  static public <A> List<A> replace(List<A> l, A a, A b) {
    for (int i = 0; i < l(l); i++) if (eq(l.get(i), a))
      l.set(i, b);
    return l;
  }

  static public <A> List<A> replace(A a, A b, List<A> l) {
    return replace(l, a, b);
  }

  static public String replace(String s, String a, String b) {
    return s == null ? null : a == null || b == null ? s : s.replace(a, b);
  }

  static public String replace(String s, char a, char b) {
    return s == null ? null : s.replace(a, b);
  }

  static public String getCanonicalPath(File f) {
    try {
      return f == null ? null : f.getCanonicalPath();
    } catch (Exception __e) {
      throw rethrow(__e);
    }
  }

  static public String getCanonicalPath(String path) {
    return getCanonicalPath(newFile(path));
  }

  static public AutoCloseable tempCleaningUp() {
    AutoCloseable result = null;
    result = tempSetTL(ping_isCleanUpThread, true);
    return result;
  }

  static public void closeAllWriters(Collection<? extends Writer> l) {
    for (Writer w : unnull(l)) {
      try {
        w.close();
      } catch (Throwable __e) {
        printStackTrace(__e);
      }
    }
  }

  static public File prepareProgramFile(String name) {
    return mkdirsForFile(getProgramFile(name));
  }

  static public File prepareProgramFile(String progID, String name) {
    return mkdirsForFile(getProgramFile(progID, name));
  }

  static public String str_nullIfEmpty(Object o) {
    return nullIfEmpty(strOrNull(o));
  }

  static public <A extends DynamicObject> A setDyn(A o, String key, Object value) {
    setDynObjectValue(o, key, value);
    return o;
  }

  static public void setDyn(IMeta o, String key, Object value) {
    metaMapPut(o, key, value);
  }

  static public <A, B> B getOrCreate(Map<A, B> map, A key, Class<? extends B> c) {
    try {
      B b = map.get(key);
      if (b == null)
        map.put(key, b = c.newInstance());
      return b;
    } catch (Exception __e) {
      throw rethrow(__e);
    }
  }

  static public <A, B> B getOrCreate(Map<A, B> map, A key, Object f) {
    try {
      B b = map.get(key);
      if (b == null)
        map.put(key, b = (B) callF(f));
      return b;
    } catch (Exception __e) {
      throw rethrow(__e);
    }
  }

  static public <A, B> B getOrCreate(IF0<B> f, Map<A, B> map, A key) {
    return getOrCreate(map, key, f);
  }

  static public <A, B> B getOrCreate(Map<A, B> map, A key, IF0<B> f) {
    B b = map.get(key);
    if (b == null)
      map.put(key, b = f.get());
    return b;
  }

  static public <A, B> B getOrCreate(Class<? extends B> c, Map<A, B> map, A key) {
    return getOrCreate(map, key, c);
  }

  static public Comparator<String> caseInsensitiveComparator() {
    return betterCIComparator();
  }

  static public Object[] dropEntryFromParams(Object[] params, int i) {
    int n = l(params);
    if (i < 0 || i >= n)
      return params;
    if (n == 2)
      return null;
    Object[] p = new Object[n - 2];
    System.arraycopy(params, 0, p, 0, i);
    System.arraycopy(params, i + 2, p, i, n - i - 2);
    return p;
  }

  static public <A extends Concept> List<A> filterConcepts(List<A> list, Object... params) {
    if (empty(params))
      return list;
    List<A> l = new ArrayList();
    for (A x : list) if (checkConceptFields(x, params))
      l.add(x);
    return l;
  }

  static public int cmpAlphaNum(String a, String b) {
    return alphaNumComparator().compare(a, b);
  }

  static public <A> A printHidingCredentials(A o) {
    print(hideCredentials(str(o)));
    return o;
  }

  static public void logQuotedWithDate(String s) {
    logQuotedWithTime(s);
  }

  static public void logQuotedWithDate(String logFile, String s) {
    logQuotedWithTime(logFile, s);
  }

  static public void logQuotedWithDate(File logFile, String s) {
    logQuotedWithTime(logFile, s);
  }

  static public File infoBoxesLogFile() {
    return new File(javaxDataDir(), "Logs/infoBoxes.txt");
  }

  static public JWindow makeWindow(final Component c) {
    return swing(new F0<JWindow>() {

      public JWindow get() {
        try {
          JWindow w = new JWindow();
          w.add(wrap(c));
          return w;
        } catch (Exception __e) {
          throw rethrow(__e);
        }
      }

      public String toString() {
        return "new JWindow w;\r\n    w.add(wrap(c));\r\n    ret w;";
      }
    });
  }

  static public JPanel infoMessage_makePanel(String text) {
    final JTextArea ta = wrappedTextArea(text);
    onClick(ta, new Runnable() {

      public void run() {
        try {
          disposeWindow(ta);
        } catch (Exception __e) {
          throw rethrow(__e);
        }
      }

      public String toString() {
        return "disposeWindow(ta)";
      }
    });
    int size = 14;
    if (l(text) <= 50)
      size *= 2;
    else if (l(text) < 100)
      size = iround(size * 1.5);
    ta.setFont(typeWriterFont(size));
    JScrollPane sp = jscroll(ta);
    return withMargin(sp);
  }

  static public int moveToTopRightCorner_inset = 20;

  static public <A extends Component> A moveToTopRightCorner(A a) {
    return moveToTopRightCorner(moveToTopRightCorner_inset, moveToTopRightCorner_inset, a);
  }

  static public <A extends Component> A moveToTopRightCorner(int insetX, int insetY, A a) {
    {
      swing(() -> {
        Window w = getWindow(a);
        if (w != null) {
          var bounds = preferredScreenBounds();
          w.setLocation(bounds.x2() - w.getWidth() - insetX, bounds.y1() + insetY);
        }
      });
    }
    return a;
  }

  static public boolean vmBus_noObjections(String msg, Object... args) {
    return !vmBus_anyFalse(msg, args);
  }

  static public <A extends Window> A disposeWindowAfter(int delay, final A w) {
    if (w != null)
      swingLater(delay, new Runnable() {

        public void run() {
          try {
            w.dispose();
          } catch (Exception __e) {
            throw rethrow(__e);
          }
        }

        public String toString() {
          return "w.dispose();";
        }
      });
    return w;
  }

  static public <A extends Window> A disposeWindowAfter(A w, double seconds) {
    return disposeWindowAfter(toMS_int(seconds), w);
  }

  static public <A extends Window> A disposeWindowAfter(double seconds, A w) {
    return disposeWindowAfter(w, seconds);
  }

  static public Runnable addThreadInfoToRunnable(final Object r) {
    final Object info = _threadInfo();
    return info == null ? asRunnable(r) : new Runnable() {

      public void run() {
        try {
          _inheritThreadInfo(info);
          callF(r);
        } catch (Exception __e) {
          throw rethrow(__e);
        }
      }

      public String toString() {
        return "_inheritThreadInfo(info); callF(r);";
      }
    };
  }

  static public boolean isMenuSeparatorIndicator(Object o) {
    return eqOneOf(o, "***", "---", "===", "");
  }

  static public int menuItemCount(JMenu menu) {
    return menu == null ? 0 : swing(() -> menu.getItemCount());
  }

  static public boolean isRunnableX(Object o) {
    if (o == null)
      return false;
    if (o instanceof String)
      return hasMethod(mc(), (String) o);
    return o instanceof Runnable || hasMethod(o, "get");
  }

  static public boolean jmenuItem_newThreads = false;

  static public JMenuItem jmenuItem(final String text) {
    return jMenuItem(text, null);
  }

  static public JMenuItem jmenuItem(final String text, final Object r) {
    return swing(new F0<JMenuItem>() {

      public JMenuItem get() {
        try {
          Pair<String, Integer> p = jmenu_autoMnemonic(dropPrefix("[disabled] ", text));
          JMenuItem mi = new JMenuItem(p.a);
          if (startsWith(text, "[disabled] "))
            disableMenuItem(mi);
          if (p.b != 0)
            mi.setMnemonic(p.b);
          mi.addActionListener(jmenuItem_newThreads ? actionListenerInNewThread(r) : actionListener(r));
          return mi;
        } catch (Exception __e) {
          throw rethrow(__e);
        }
      }

      public String toString() {
        return "Pair<S, Int> p = jmenu_autoMnemonic(dropPrefix(\"[disabled] \", text));\r\n    JM...";
      }
    });
  }

  static public String unCurlyBracket(String s) {
    return tok_unCurlyBracket(s);
  }

  static public <A extends JComponent> A bindLiveValueListenerToComponent(A component, IHasChangeListeners lv, Runnable listener) {
    return bindHasChangeListenersToComponent(component, lv, listener);
  }

  static public boolean isCurlyBracketed(String s) {
    return isCurlyBraced(s);
  }

  static public void caretToHome(JTextComponent c) {
    setCaret(c, 0);
  }

  static public Font typeWriterFont() {
    return typeWriterFont(iround(14 * getSwingFontScale()));
  }

  static public Font typeWriterFont(int size) {
    return new Font("Courier", Font.PLAIN, size);
  }

  static public JPanel centerAndEast(final Component c, final Component e) {
    return swing(new F0<JPanel>() {

      public JPanel get() {
        try {
          JPanel panel = new JPanel(new BorderLayout());
          panel.add(BorderLayout.CENTER, wrap(c));
          panel.add(BorderLayout.EAST, wrap(e));
          return panel;
        } catch (Exception __e) {
          throw rethrow(__e);
        }
      }

      public String toString() {
        return "JPanel panel = new JPanel(new BorderLayout);\r\n    panel.add(BorderLayout.CENT...";
      }
    });
  }

  static public int withLeftMargin_defaultWidth = 6;

  static public JPanel withLeftMargin(Component c) {
    return withLeftMargin(withLeftMargin_defaultWidth, c);
  }

  static public JPanel withLeftMargin(final int margin, final Component c) {
    return swing(new F0<JPanel>() {

      public JPanel get() {
        try {
          JPanel p = new JPanel(new BorderLayout());
          p.setBorder(BorderFactory.createEmptyBorder(0, margin, 0, 0));
          p.add(c);
          return p;
        } catch (Exception __e) {
          throw rethrow(__e);
        }
      }

      public String toString() {
        return "JPanel p = new JPanel(new BorderLayout);\r\n    p.setBorder(BorderFactory.creat...";
      }
    });
  }

  static public <A extends JComponent> A setBorder(Border border, A c) {
    if (c != null) {
      swing(() -> {
        c.setBorder(border);
      });
    }
    return c;
  }

  static public <A extends JComponent> A setBorder(A c, Border border) {
    return setBorder(border, c);
  }

  static public JScrollPane withoutViewportBorder(JScrollPane sp) {
    if (sp != null) {
      swing(() -> {
        sp.setViewportBorder(null);
      });
    }
    return sp;
  }

  static public void setMetaAndVerify(Object o, Object key, Object value) {
    setMeta(o, key, value);
    assertSame(() -> "setMeta failed (class: " + className(o) + ", key: " + key + ")", value, metaGet(o, key));
  }

  static public void setMetaAndVerify(IMeta o, Object key, Object value) {
    setMeta(o, key, value);
    assertSame(() -> "setMeta failed (class: " + className(o) + ", key: " + key + ")", value, metaGet(o, key));
  }

  static public <A extends JComponent> A onFirstComponentShow(final A component, final Runnable onShow) {
    {
      swing(() -> {
        component.addAncestorListener(new AncestorListener() {

          public void ancestorAdded(AncestorEvent event) {
            component.removeAncestorListener(this);
            pcallF(onShow);
          }

          public void ancestorRemoved(AncestorEvent event) {
          }

          public void ancestorMoved(AncestorEvent event) {
          }
        });
      });
    }
    return component;
  }

  static public <A extends JTextComponent> A setTextKeepCaret(final String text, final A c) {
    if (c != null) {
      swing(() -> {
        int caret = c.getCaretPosition();
        setText(c, text);
        setCaretPosition(c, caret);
      });
    }
    return c;
  }

  static public <A extends JTextComponent> A setTextKeepCaret(A c, String text) {
    return setTextKeepCaret(text, c);
  }

  static public Timer installTimer(JComponent component, Object r, long delay) {
    return installTimer(component, r, delay, delay);
  }

  static public Timer installTimer(RootPaneContainer frame, long delay, Object r) {
    return installTimer(frame.getRootPane(), r, delay, delay);
  }

  static public Timer installTimer(JComponent component, long delay, Object r) {
    return installTimer(component, r, delay, delay);
  }

  static public Timer installTimer(JComponent component, long delay, long firstDelay, Object r) {
    return installTimer(component, r, delay, firstDelay);
  }

  static public Timer installTimer(final JComponent component, final Object r, final long delay, final long firstDelay) {
    return installTimer(component, r, delay, firstDelay, true);
  }

  static public Timer installTimer(final JComponent component, final Object r, final long delay, final long firstDelay, final boolean repeats) {
    if (component == null)
      return null;
    return (Timer) swingAndWait(new F0<Object>() {

      public Object get() {
        try {
          final Var<Timer> timer = new Var();
          timer.set(new Timer(toInt(delay), new java.awt.event.ActionListener() {

            public void actionPerformed(java.awt.event.ActionEvent _evt) {
              try {
                AutoCloseable __1 = tempActivity(r);
                try {
                  try {
                    if (!allPaused())
                      if (isFalse(callF(r)))
                        cancelTimer(timer.get());
                  } catch (Throwable __e) {
                    printStackTrace(__e);
                  }
                } finally {
                  _close(__1);
                }
              } catch (Throwable __e) {
                messageBox(__e);
              }
            }
          }));
          timer.get().setInitialDelay(toInt(firstDelay));
          timer.get().setRepeats(repeats);
          bindTimerToComponent(timer.get(), component);
          return timer.get();
        } catch (Exception __e) {
          throw rethrow(__e);
        }
      }

      public String toString() {
        return "final new Var<Timer> timer;\r\n    timer.set(new Timer(toInt(delay), actionList...";
      }
    });
  }

  static public Timer installTimer(RootPaneContainer frame, long delay, long firstDelay, Object r) {
    return installTimer(frame.getRootPane(), delay, firstDelay, r);
  }

  static public JRootPane getRootPane(Component c) {
    Component f = (Component) getPossiblyInternalFrame(c);
    return f instanceof RootPaneContainer ? (JRootPane) swingCall(f, "getRootPane") : null;
  }

  static public <A extends Component> A _recordNewSwingComponent(A c) {
    if (c != null)
      callF((Object) vm_generalMap_get("newSwingComponentRegistry"), (Object) c);
    return c;
  }

  static public JComponent componentToJComponent(Component c) {
    if (c instanceof JComponent)
      return (JComponent) c;
    if (c instanceof JFrame)
      return ((JFrame) c).getRootPane();
    if (c == null)
      return null;
    throw fail("boohoo " + getClassName(c));
  }

  static public class jLiveValueSection_class extends SingleComponentPanel {

    public LiveValue<?> liveValue;

    public String getTitle() {
      return strOrEmpty(liveValue.get());
    }

    public jLiveValueSection_class(LiveValue<?> lv, Component c) {
      super(c);
      bindLiveValueListenerToComponent(this, liveValue = lv, new Runnable() {

        public void run() {
          try {
            swingLater(new Runnable() {

              public void run() {
                try {
                  setBorder(BorderFactory.createTitledBorder(BorderFactory.createBevelBorder(BevelBorder.LOWERED), getTitle()));
                  revalidate();
                } catch (Exception __e) {
                  throw rethrow(__e);
                }
              }

              public String toString() {
                return "setBorder(BorderFactory.createTitledBorder(\r\n        BorderFactory.createBeve...";
              }
            });
          } catch (Exception __e) {
            throw rethrow(__e);
          }
        }

        public String toString() {
          return "swingLater(r {\r\n      setBorder(BorderFactory.createTitledBorder(\r\n        Bo...";
        }
      });
    }
  }

  static public JPanel jLiveValueSection(LiveValue<?> lv, Component c) {
    return swingNu(jLiveValueSection_class.class, lv, c);
  }

  static public JButton basicJButton(String text) {
    return swing(() -> new JButton(text));
  }

  static public <A extends JComponent> A jtransparent(final A a) {
    {
      swing(() -> {
        a.setOpaque(false);
      });
    }
    return a;
  }

  static public JPanel borderLayoutPanel() {
    return jpanel(new BorderLayout());
  }

  static public boolean isCurrentThread(Thread t) {
    return t != null && t == currentThread();
  }

  static public JButton jimageButtonScaledToWidth(int w, String imageID, Runnable action) {
    return jimageButtonScaledToWidth(w, imageID, "", action);
  }

  static public JButton jimageButtonScaledToWidth(int w, String imageID, String toolTip, Runnable action) {
    return jimageButton(scaleImageToWidth(w, imageID), toolTip, action);
  }

  static public String errorIconID() {
    return "#1101390";
  }

  static public JComponent showErrorFrame(Throwable e) {
    return showTextWordWrapped("Error", renderStackTrace((e)));
  }

  static public JLabel jlabel_noAutoToolTip() {
    return jlabel_noAutoToolTip(" ");
  }

  static public JLabel jlabel_noAutoToolTip(String text) {
    var lbl = swingConstruct(BetterLabel.class, text);
    lbl.autoToolTip = false;
    return lbl;
  }

  static public String exceptionType(Throwable e) {
    e = getInnerException(e);
    return shortClassName(e);
  }

  static public Throwable getException(Runnable r) {
    try {
      callF(r);
      return null;
    } catch (Throwable e) {
      return e;
    }
  }

  static public boolean activateFrame(final Component c, Object... __) {
    return swing(new F0<Boolean>() {

      public Boolean get() {
        try {
          Frame f = getAWTFrame(c);
          if (f == null)
            return false;
          if (!f.isVisible())
            f.setVisible(true);
          boolean windowsHack = optPar("windowsHack", __, true);
          boolean iconified = f.getState() == Frame.ICONIFIED;
          boolean maximize = boolPar("maximize", __);
          if (iconified)
            f.setState(maximize ? Frame.MAXIMIZED_BOTH : Frame.NORMAL);
          if (windowsHack && !iconified && isWindows()) {
            boolean fullscreen = f.getExtendedState() == Frame.MAXIMIZED_BOTH;
            f.setExtendedState(JFrame.ICONIFIED);
            f.setExtendedState(fullscreen ? JFrame.MAXIMIZED_BOTH : JFrame.NORMAL);
          }
          f.toFront();
          return true;
        } catch (Exception __e) {
          throw rethrow(__e);
        }
      }

      public String toString() {
        return "Frame f = getAWTFrame(c);\r\n    if (f == null) false;\r\n    if (!f.isVisible())...";
      }
    });
  }

  static public Frame getAWTFrame(final Object _o) {
    return swing(new F0<Frame>() {

      public Frame get() {
        try {
          Object o = _o;
          if (o instanceof ButtonGroup)
            o = first(buttonsInGroup((ButtonGroup) o));
          if (!(o instanceof Component))
            return null;
          Component c = (Component) o;
          while (c != null) {
            if (c instanceof Frame)
              return (Frame) c;
            c = c.getParent();
          }
          return null;
        } catch (Exception __e) {
          throw rethrow(__e);
        }
      }

      public String toString() {
        return "O o = _o;\r\n    /*\r\n    ifdef HaveProcessing\r\n      if (o instanceof PApplet) ...";
      }
    });
  }

  static public JTextArea jTextArea() {
    return jTextArea("");
  }

  static public JTextArea jTextArea(final String text) {
    return jTextAreaWithUndo(text);
  }

  static public String programTitle() {
    return getProgramName();
  }

  static public JFrame getFrame(final Object _o) {
    return swing(new F0<JFrame>() {

      public JFrame get() {
        try {
          Object o = _o;
          if (o instanceof ButtonGroup)
            o = first(buttonsInGroup((ButtonGroup) o));
          if (!(o instanceof Component))
            return null;
          Component c = (Component) o;
          while (c != null) {
            if (c instanceof JFrame)
              return (JFrame) c;
            c = c.getParent();
          }
          return null;
        } catch (Exception __e) {
          throw rethrow(__e);
        }
      }

      public String toString() {
        return "O o = _o;\r\n    if (o instanceof ButtonGroup) o = first(buttonsInGroup((Button...";
      }
    });
  }

  static public JFrame setFrameIconLater(Component c, final String imageID) {
    final JFrame frame = getFrame(c);
    if (frame != null)
      startThread("Loading Icon", new Runnable() {

        public void run() {
          try {
            final Image i = imageIcon(or2(imageID, "#1005557")).getImage();
            swingLater(new Runnable() {

              public void run() {
                try {
                  frame.setIconImage(i);
                } catch (Exception __e) {
                  throw rethrow(__e);
                }
              }

              public String toString() {
                return "frame.setIconImage(i);";
              }
            });
          } catch (Exception __e) {
            throw rethrow(__e);
          }
        }

        public String toString() {
          return "final Image i = imageIcon(or2(imageID, \"#1005557\")).getImage();\r\n      swingL...";
        }
      });
    return frame;
  }

  static public void _initFrame(JFrame f) {
    myFrames_list.put(f, Boolean.TRUE);
    standardTitlePopupMenu(f);
  }

  static public Rectangle defaultNewFrameBounds_r = new Rectangle(300, 100, 500, 400);

  static public Rectangle defaultNewFrameBounds() {
    return swing(new F0<Rectangle>() {

      public Rectangle get() {
        try {
          defaultNewFrameBounds_r.translate(60, 20);
          var bounds = preferredScreenBounds();
          if (!bounds.contains(defaultNewFrameBounds_r))
            defaultNewFrameBounds_r.setLocation(centerX(bounds) + random_incl(-30, 30), centerY(bounds) + random_incl(-20, 20));
          return new Rectangle(defaultNewFrameBounds_r);
        } catch (Exception __e) {
          throw rethrow(__e);
        }
      }

      public String toString() {
        return "defaultNewFrameBounds_r.translate(60, 20);\r\n    var bounds = preferredScreenB...";
      }
    });
  }

  static public void hideConsole() {
    final JFrame frame = consoleFrame();
    if (frame != null) {
      autoVMExit();
      swingLater(new Runnable() {

        public void run() {
          try {
            frame.setVisible(false);
          } catch (Exception __e) {
            throw rethrow(__e);
          }
        }

        public String toString() {
          return "frame.setVisible(false);";
        }
      });
    }
  }

  static public String getProgramTitle() {
    return getProgramName();
  }

  static public <B> TreeMap<String, B> asCaseInsensitiveMap(Map<String, B> map) {
    if (isCIMap(map))
      return (TreeMap) map;
    TreeMap<String, B> m = ciMap();
    putAll(m, map);
    return m;
  }

  static public int incAtomicInt(AtomicInteger i) {
    return i.incrementAndGet();
  }

  static public int incAtomicInt(AtomicInteger i, int delta) {
    return i.addAndGet(delta);
  }

  static public List<String> javaTokC(String s) {
    if (s == null)
      return null;
    int l = s.length();
    ArrayList<String> tok = new ArrayList();
    int i = 0;
    while (i < l) {
      int j = i;
      char c, d;
      while (j < l) {
        c = s.charAt(j);
        d = j + 1 >= l ? '\0' : s.charAt(j + 1);
        if (c == ' ' || c == '\t' || c == '\r' || c == '\n')
          ++j;
        else if (c == '/' && d == '*') {
          do ++j; while (j < l && !s.substring(j, Math.min(j + 2, l)).equals("*/"));
          j = Math.min(j + 2, l);
        } else if (c == '/' && d == '/') {
          do ++j; while (j < l && "\r\n".indexOf(s.charAt(j)) < 0);
        } else
          break;
      }
      i = j;
      if (i >= l)
        break;
      c = s.charAt(i);
      d = i + 1 >= l ? '\0' : s.charAt(i + 1);
      if (c == '\'' || c == '"') {
        char opener = c;
        ++j;
        while (j < l) {
          if (s.charAt(j) == opener || s.charAt(j) == '\n') {
            ++j;
            break;
          } else if (s.charAt(j) == '\\' && j + 1 < l)
            j += 2;
          else
            ++j;
        }
      } else if (Character.isJavaIdentifierStart(c))
        do ++j; while (j < l && (Character.isJavaIdentifierPart(s.charAt(j)) || "'".indexOf(s.charAt(j)) >= 0));
      else if (Character.isDigit(c)) {
        do ++j; while (j < l && Character.isDigit(s.charAt(j)));
        if (j < l && s.charAt(j) == 'L')
          ++j;
      } else if (c == '[' && d == '[') {
        do ++j; while (j + 1 < l && !s.substring(j, j + 2).equals("]]"));
        j = Math.min(j + 2, l);
      } else if (c == '[' && d == '=' && i + 2 < l && s.charAt(i + 2) == '[') {
        do ++j; while (j + 2 < l && !s.substring(j, j + 3).equals("]=]"));
        j = Math.min(j + 3, l);
      } else
        ++j;
      tok.add(javaTok_substringC(s, i, j));
      i = j;
    }
    return tok;
  }

  static public GZIPInputStream newGZIPInputStream(File f) {
    return gzInputStream(f);
  }

  static public GZIPInputStream newGZIPInputStream(InputStream in) {
    return gzInputStream(in);
  }

  static public Object unstructure(String text) {
    return unstructure(text, false);
  }

  static public Object unstructure(String text, boolean allDynamic) {
    return unstructure(text, allDynamic, null);
  }

  static public Object unstructure(String text, IF1<String, Class> classFinder) {
    return unstructure(text, false, classFinder);
  }

  static public int structure_internStringsLongerThan = 50;

  static public int unstructure_unquoteBufSize = 100;

  static public int unstructure_tokrefs;

  abstract static public class unstructure_Receiver {

    abstract public void set(Object o);
  }

  static public Object unstructure(String text, boolean allDynamic, Object classFinder) {
    if (text == null)
      return null;
    return unstructure_tok(javaTokC_noMLS_iterator(text), allDynamic, classFinder);
  }

  static public Object unstructure_reader(BufferedReader reader) {
    return unstructure_tok(javaTokC_noMLS_onReader(reader), false, null);
  }

  public interface unstructure_Handler {

    public void parse(int refID, int tokIndex, unstructure_Receiver out);
  }

  static public Object unstructure_tok(final Producer<String> tok, final boolean allDynamic, final Object _classFinder) {
    final boolean debug = unstructure_debug;
    final class X {

      public int i = -1;

      final public Object classFinder = _classFinder != null ? _classFinder : _defaultClassFinder();

      public String mcDollar = actualMCDollar();

      public HashMap<Integer, Object> refs = new HashMap();

      public HashMap<Integer, Object> tokrefs = new HashMap();

      public HashSet<String> concepts = new HashSet();

      public List<Runnable> stack = new ArrayList();

      public Map<String, String> baseClassMap = new HashMap();

      public HashMap<Class, Constructor> innerClassConstructors = new HashMap();

      public String curT;

      public char[] unquoteBuf = new char[unstructure_unquoteBufSize];

      final public HashMap<String, Object> handlers = new HashMap();

      public X() {
        try {
          Class mc = (Class) (callF(_classFinder, "<main>"));
          if (mc != null)
            mcDollar = mc.getName() + "$";
        } catch (Throwable __e) {
          printStackTrace(__e);
        }
        makeHandlers();
      }

      public void makeHandlers() {
        unstructure_Handler h;
        handlers.put("bigint", (unstructure_Handler) (refID, tokIndex, out) -> out.set(parseBigInt()));
        handlers.put("d", (unstructure_Handler) (refID, tokIndex, out) -> out.set(parseDouble()));
        handlers.put("fl", (unstructure_Handler) (refID, tokIndex, out) -> out.set(parseFloat()));
        handlers.put("sh", (unstructure_Handler) (refID, tokIndex, out) -> {
          consume();
          String t = tpp();
          if (t.equals("-")) {
            t = tpp();
            out.set((short) (-parseInt(t)));
            return;
          }
          out.set((short) parseInt(t));
        });
        handlers.put("enum", (unstructure_Handler) (refID, tokIndex, out) -> {
          consume();
          String t = tpp();
          assertTrue(isJavaIdentifier(t));
          String fullClassName = mcDollar + t;
          Class _c = findAClass(fullClassName);
          if (_c == null)
            throw fail("Enum class not found: " + fullClassName);
          int ordinal = parseInt(tpp());
          out.set(_c.getEnumConstants()[ordinal]);
        });
        handlers.put("false", h = (unstructure_Handler) (refID, tokIndex, out) -> {
          consume();
          out.set(false);
        });
        handlers.put("f", h);
        handlers.put("true", h = (unstructure_Handler) (refID, tokIndex, out) -> {
          consume();
          out.set(true);
        });
        handlers.put("t", h);
        handlers.put("{", (unstructure_Handler) (refID, tokIndex, out) -> parseMap(out));
        handlers.put("[", (unstructure_Handler) (refID, tokIndex, out) -> {
          ArrayList l = new ArrayList();
          if (refID >= 0)
            refs.put(refID, l);
          this.parseList(l, out);
        });
        handlers.put("bitset", (unstructure_Handler) (refID, tokIndex, out) -> parseBitSet(out));
        handlers.put("array", h = (unstructure_Handler) (refID, tokIndex, out) -> parseArray(out));
        handlers.put("intarray", h);
        handlers.put("dblarray", h);
      }

      public Class findAClass(String fullClassName) {
        try {
          return classFinder != null ? (Class) callF(classFinder, fullClassName) : findClass_fullName(fullClassName);
        } catch (Throwable __e) {
          return null;
        }
      }

      public String unquote(String s) {
        return unquoteUsingCharArray(s, unquoteBuf);
      }

      public String t() {
        return curT;
      }

      public String tpp() {
        String t = curT;
        consume();
        return t;
      }

      public void parse(final unstructure_Receiver out) {
        String t = t();
        int refID;
        if (structure_isMarker(t, 0, l(t))) {
          refID = parseInt(t.substring(1));
          consume();
        } else
          refID = -1;
        final int tokIndex = i;
        parse_inner(refID, tokIndex, new unstructure_Receiver() {

          public void set(Object o) {
            if (refID >= 0)
              refs.put(refID, o);
            if (o != null)
              tokrefs.put(tokIndex, o);
            out.set(o);
          }
        });
      }

      public void parse_inner(int refID, int tokIndex, unstructure_Receiver out) {
        String t = t();
        Object handler = handlers.get(t);
        if (handler instanceof unstructure_Handler) {
          ((unstructure_Handler) handler).parse(refID, tokIndex, out);
          return;
        }
        Class c = (Class) handler;
        if (c == null) {
          if (t.startsWith("\"")) {
            String s = internIfLongerThan(unquote(tpp()), structure_internStringsLongerThan);
            out.set(s);
            return;
          }
          if (t.startsWith("'")) {
            out.set(unquoteCharacter(tpp()));
            return;
          }
          if (t.equals("-")) {
            consume();
            t = tpp();
            out.set(isLongConstant(t) ? (Object) (-parseLong(t)) : (Object) (-parseInt(t)));
            return;
          }
          if (isInteger(t) || isLongConstant(t)) {
            consume();
            if (isLongConstant(t)) {
              out.set(parseLong(t));
              return;
            }
            long l = parseLong(t);
            boolean isInt = l == (int) l;
            out.set(isInt ? (Object) Integer.valueOf((int) l) : (Object) Long.valueOf(l));
            return;
          }
          if (t.equals("-")) {
            consume();
            t = tpp();
            out.set(isLongConstant(t) ? (Object) (-parseLong(t)) : (Object) (-parseInt(t)));
            return;
          }
          if (isInteger(t) || isLongConstant(t)) {
            consume();
            if (isLongConstant(t)) {
              out.set(parseLong(t));
              return;
            }
            long l = parseLong(t);
            boolean isInt = l == (int) l;
            out.set(isInt ? (Object) Integer.valueOf((int) l) : (Object) Long.valueOf(l));
            return;
          }
          if (t.equals("File")) {
            consume();
            File f = new File(unquote(tpp()));
            out.set(f);
            return;
          }
          if (t.startsWith("r") && isInteger(t.substring(1))) {
            consume();
            int ref = Integer.parseInt(t.substring(1));
            Object o = refs.get(ref);
            if (o == null)
              warn("unsatisfied back reference " + ref);
            out.set(o);
            return;
          }
          if (t.startsWith("t") && isInteger(t.substring(1))) {
            consume();
            int ref = Integer.parseInt(t.substring(1));
            Object o = tokrefs.get(ref);
            if (o == null)
              warn("unsatisfied token reference " + ref + " at " + tokIndex);
            out.set(o);
            return;
          }
          if (t.equals("hashset")) {
            parseHashSet(out);
            return;
          }
          if (t.equals("lhs")) {
            parseLinkedHashSet(out);
            return;
          }
          if (t.equals("treeset")) {
            parseTreeSet(out);
            return;
          }
          if (t.equals("ciset")) {
            parseCISet(out);
            return;
          }
          if (eqOneOf(t, "hashmap", "hm")) {
            consume();
            parseMap(new HashMap(), out);
            return;
          }
          if (t.equals("lhm")) {
            consume();
            parseMap(new LinkedHashMap(), out);
            return;
          }
          if (t.equals("tm")) {
            consume();
            parseMap(new TreeMap(), out);
            return;
          }
          if (t.equals("cimap")) {
            consume();
            parseMap(ciMap(), out);
            return;
          }
          if (t.equals("ll")) {
            consume();
            LinkedList l = new LinkedList();
            if (refID >= 0)
              refs.put(refID, l);
            {
              parseList(l, out);
              return;
            }
          }
          if (t.equals("syncLL")) {
            consume();
            {
              parseList(synchroLinkedList(), out);
              return;
            }
          }
          if (t.equals("sync")) {
            consume();
            {
              parse(new unstructure_Receiver() {

                public void set(Object value) {
                  if (value instanceof Map) {
                    if (value instanceof NavigableMap) {
                      out.set(synchroNavigableMap((NavigableMap) value));
                      return;
                    }
                    if (value instanceof SortedMap) {
                      out.set(synchroSortedMap((SortedMap) value));
                      return;
                    }
                    {
                      out.set(synchroMap((Map) value));
                      return;
                    }
                  } else {
                    out.set(synchroList((List) value));
                    return;
                  }
                }
              });
              return;
            }
          }
          if (t.equals("ba")) {
            consume();
            String hex = unquote(tpp());
            out.set(hexToBytes(hex));
            return;
          }
          if (t.equals("boolarray")) {
            consume();
            int n = parseInt(tpp());
            String hex = unquote(tpp());
            out.set(boolArrayFromBytes(hexToBytes(hex), n));
            return;
          }
          if (t.equals("class")) {
            out.set(parseClass());
            return;
          }
          if (t.equals("l")) {
            parseLisp(out);
            return;
          }
          if (t.equals("null")) {
            consume();
            out.set(null);
            return;
          }
          if (eq(t, "c")) {
            consume();
            t = t();
            assertTrue(isJavaIdentifier(t));
            concepts.add(t);
          }
          if (eq(t, "cu")) {
            consume();
            t = tpp();
            assertTrue(isJavaIdentifier(t));
            String fullClassName = mcDollar + t;
            Class _c = findAClass(fullClassName);
            if (_c == null)
              throw fail("Class not found: " + fullClassName);
            parse(new unstructure_Receiver() {

              public void set(Object value) {
                out.set(call(_c, "_deserialize", value));
              }
            });
            return;
          }
        }
        if (eq(t, "j")) {
          consume();
          out.set(parseJava());
          return;
        }
        if (eq(t, "bc")) {
          consume();
          String c1 = tpp();
          String c2 = tpp();
          baseClassMap.put(c1, c2);
          {
            parse_inner(refID, i, out);
            return;
          }
        }
        if (c == null && !isJavaIdentifier(t))
          throw new RuntimeException("Unknown token " + (i + 1) + ": " + quote(t));
        consume();
        String className, fullClassName;
        if (eq(t(), ".")) {
          consume();
          className = fullClassName = t + "." + assertIdentifier(tpp());
        } else {
          className = t;
          fullClassName = mcDollar + t;
        }
        if (c == null && !allDynamic) {
          c = findAClass(fullClassName);
          handlers.put(className, c);
        }
        if (c == null && !allDynamic) {
          Set<String> seen = new HashSet();
          String parent = className;
          while (true) {
            String baseName = baseClassMap.get(parent);
            if (baseName == null)
              break;
            if (!seen.add(baseName))
              throw fail("Cyclic superclass info: " + baseName);
            c = findAClass(mcDollar + baseName);
            if (c == null)
              print("Base class " + baseName + " of " + parent + " doesn't exist either");
            else if (isAbstract(c))
              print("Can't instantiate abstract base class: " + c);
            else {
              printVars_str("Reverting to base class", "className", className, "baseName", baseName, "c", c);
              handlers.put(className, c);
              break;
            }
            parent = baseName;
          }
        }
        boolean hasBracket = eq(t(), "(");
        if (hasBracket)
          consume();
        boolean hasOuter = hasBracket && startsWith(t(), "this$");
        DynamicObject dO = null;
        Object o = null;
        final String thingName = t;
        if (c != null) {
          if (hasOuter)
            try {
              Constructor ctor = innerClassConstructors.get(c);
              if (ctor == null)
                innerClassConstructors.put(c, ctor = nuStubInnerObject_findConstructor(c, classFinder));
              o = ctor.newInstance(new Object[] { null });
            } catch (Exception e) {
              print("Error deserializing " + c + ": " + e);
              o = nuEmptyObject(c);
            }
          else
            o = nuEmptyObject(c);
          if (o instanceof DynamicObject)
            dO = (DynamicObject) o;
        } else {
          if (concepts.contains(t) && (c = findAClass(mcDollar + "Concept")) != null)
            o = dO = (DynamicObject) nuEmptyObject(c);
          else
            dO = new DynamicObject();
          dO.className = className;
        }
        if (refID >= 0)
          refs.put(refID, o != null ? o : dO);
        tokrefs.put(tokIndex, o != null ? o : dO);
        HashMap<String, Object> fields = new HashMap();
        Object _o = o;
        DynamicObject _dO = dO;
        if (hasBracket) {
          stack.add(new Runnable() {

            public void run() {
              try {
                if (eq(t(), ","))
                  consume();
                if (eq(t(), ")")) {
                  consume(")");
                  objRead(_o, _dO, fields, hasOuter);
                  out.set(_o != null ? _o : _dO);
                } else {
                  final String key = unquote(tpp());
                  String t = tpp();
                  if (!eq(t, "="))
                    throw fail("= expected, got " + t + " after " + quote(key) + " in object " + thingName);
                  stack.add(this);
                  parse(new unstructure_Receiver() {

                    public void set(Object value) {
                      fields.put(key, value);
                    }
                  });
                }
              } catch (Exception __e) {
                throw rethrow(__e);
              }
            }

            public String toString() {
              return "ifdef unstructure_debug\r\n            print(\"in object values, token: \" + t())...";
            }
          });
        } else {
          objRead(o, dO, fields, hasOuter);
          out.set(o != null ? o : dO);
        }
      }

      public void objRead(Object o, DynamicObject dO, Map<String, Object> fields, boolean hasOuter) {
        Object outer = fields.get("this$0");
        if (outer != null)
          fields.put("this$1", outer);
        else {
          outer = fields.get("this$1");
          if (outer != null)
            fields.put("this$0", outer);
        }
        if (o != null) {
          if (dO != null) {
            setOptAllDyn_pcall(dO, fields);
          } else {
            setOptAll_pcall(o, fields);
          }
          if (hasOuter)
            fixOuterRefs(o);
        } else
          for (Map.Entry<String, Object> e : fields.entrySet()) setDynObjectValue(dO, intern(e.getKey()), e.getValue());
        if (o != null)
          pcallOpt_noArgs(o, "_doneLoading");
      }

      public void parseSet(final Set set, final unstructure_Receiver out) {
        this.parseList(new ArrayList(), new unstructure_Receiver() {

          public void set(Object o) {
            set.addAll((List) o);
            out.set(set);
          }
        });
      }

      public void parseLisp(final unstructure_Receiver out) {
        throw fail("class Lisp not included");
      }

      public void parseBitSet(final unstructure_Receiver out) {
        consume("bitset");
        consume("{");
        final BitSet bs = new BitSet();
        stack.add(new Runnable() {

          public void run() {
            try {
              if (eq(t(), "}")) {
                consume("}");
                out.set(bs);
              } else {
                stack.add(this);
                parse(new unstructure_Receiver() {

                  public void set(Object o) {
                    bs.set((Integer) o);
                    if (eq(t(), ","))
                      consume();
                  }
                });
              }
            } catch (Exception __e) {
              throw rethrow(__e);
            }
          }

          public String toString() {
            return "if (eq(t(), \"}\")) {\r\n          consume(\"}\");\r\n          out.set(bs);\r\n       ...";
          }
        });
      }

      public void parseList(final List list, final unstructure_Receiver out) {
        tokrefs.put(i, list);
        consume("[");
        stack.add(new Runnable() {

          public void run() {
            try {
              if (eq(t(), "]")) {
                consume();
                out.set(list);
              } else {
                stack.add(this);
                parse(new unstructure_Receiver() {

                  public void set(Object o) {
                    list.add(o);
                    if (eq(t(), ","))
                      consume();
                  }
                });
              }
            } catch (Exception __e) {
              throw rethrow(__e);
            }
          }

          public String toString() {
            return "if (eq(t(), \"]\")) {\r\n          consume();\r\n          ifdef unstructure_debug\r...";
          }
        });
      }

      public void parseArray(unstructure_Receiver out) {
        String _type = tpp();
        int dims;
        if (eq(t(), "S")) {
          _type = "S";
          consume();
        }
        if (eq(t(), "/")) {
          consume();
          dims = parseInt(tpp());
        } else
          dims = 1;
        consume("{");
        List list = new ArrayList();
        String type = _type;
        stack.add(new Runnable() {

          public void run() {
            try {
              if (eq(t(), "}")) {
                consume("}");
                if (dims > 1) {
                  Class atype;
                  if (type.equals("intarray"))
                    atype = int.class;
                  else if (type.equals("S"))
                    atype = String.class;
                  else
                    throw todo("multi-dimensional arrays of other types");
                  out.set(list.toArray((Object[]) newMultiDimensionalOuterArray(atype, dims, l(list))));
                } else
                  out.set(type.equals("intarray") ? toIntArray(list) : type.equals("dblarray") ? toDoubleArray(list) : type.equals("S") ? toStringArray(list) : list.toArray());
              } else {
                stack.add(this);
                parse(new unstructure_Receiver() {

                  public void set(Object o) {
                    list.add(o);
                    if (eq(t(), ","))
                      consume();
                  }
                });
              }
            } catch (Exception __e) {
              throw rethrow(__e);
            }
          }

          public String toString() {
            return "if (eq(t(), \"}\")) {\r\n          consume(\"}\");\r\n          if (dims > 1) {\r\n    ...";
          }
        });
      }

      public Object parseClass() {
        consume("class");
        consume("(");
        String name = unquote(tpp());
        consume(")");
        Class c = allDynamic ? null : findAClass(name);
        if (c != null)
          return c;
        DynamicObject dO = new DynamicObject();
        dO.className = "java.lang.Class";
        name = dropPrefix(mcDollar, name);
        dO.fieldValues.put("name", name);
        return dO;
      }

      public Object parseBigInt() {
        consume("bigint");
        consume("(");
        String val = tpp();
        if (eq(val, "-"))
          val = "-" + tpp();
        consume(")");
        return new BigInteger(val);
      }

      public Object parseDouble() {
        consume("d");
        consume("(");
        String val = unquote(tpp());
        consume(")");
        return Double.parseDouble(val);
      }

      public Object parseFloat() {
        consume("fl");
        String val;
        if (eq(t(), "(")) {
          consume("(");
          val = unquote(tpp());
          consume(")");
        } else {
          val = unquote(tpp());
        }
        return Float.parseFloat(val);
      }

      public void parseHashSet(unstructure_Receiver out) {
        consume("hashset");
        parseSet(new HashSet(), out);
      }

      public void parseLinkedHashSet(unstructure_Receiver out) {
        consume("lhs");
        parseSet(new LinkedHashSet(), out);
      }

      public void parseTreeSet(unstructure_Receiver out) {
        consume("treeset");
        parseSet(new TreeSet(), out);
      }

      public void parseCISet(unstructure_Receiver out) {
        consume("ciset");
        parseSet(ciSet(), out);
      }

      public void parseMap(unstructure_Receiver out) {
        parseMap(new TreeMap(), out);
      }

      public Object parseJava() {
        String j = unquote(tpp());
        Matches m = new Matches();
        if (jmatch("java.awt.Color[r=*,g=*,b=*]", j, m))
          return nuObject("java.awt.Color", parseInt(m.unq(0)), parseInt(m.unq(1)), parseInt(m.unq(2)));
        else {
          warn("Unknown Java object: " + j);
          return null;
        }
      }

      public void parseMap(final Map map, final unstructure_Receiver out) {
        consume("{");
        stack.add(new Runnable() {

          public boolean v = false;

          public Object key;

          public void run() {
            if (v) {
              v = false;
              stack.add(this);
              if (!eq(tpp(), "="))
                throw fail("= expected, got " + t() + " in map of size " + l(map));
              parse(new unstructure_Receiver() {

                public void set(Object value) {
                  map.put(key, value);
                  if (eq(t(), ","))
                    consume();
                }
              });
            } else {
              if (eq(t(), "}")) {
                consume("}");
                out.set(map);
              } else {
                v = true;
                stack.add(this);
                parse(new unstructure_Receiver() {

                  public void set(Object o) {
                    key = o;
                  }
                });
              }
            }
          }
        });
      }

      public void consume() {
        curT = tok.next();
        ++i;
      }

      public void consume(String s) {
        if (!eq(t(), s)) {
          throw fail(quote(s) + " expected, got " + quote(t()));
        }
        consume();
      }

      public void parse_initial(unstructure_Receiver out) {
        consume();
        parse(out);
        while (nempty(stack)) popLast(stack).run();
      }
    }
    ThreadLocal<Boolean> tlLoading = dynamicObjectIsLoading_threadLocal();
    Boolean b = tlLoading.get();
    tlLoading.set(true);
    try {
      final Var v = new Var();
      X x = new X();
      x.parse_initial(new unstructure_Receiver() {

        public void set(Object o) {
          v.set(o);
        }
      });
      unstructure_tokrefs = x.tokrefs.size();
      return v.get();
    } finally {
      tlLoading.set(b);
    }
  }

  static public boolean unstructure_debug = false;

  static public Producer<String> javaTokC_noMLS_onReader(final BufferedReader r) {
    final class X implements Producer<String> {

      public StringBuilder buf = new StringBuilder();

      public char c, d, e = 'x';

      public X() {
        nc();
        nc();
        nc();
      }

      public void nc() {
        try {
          c = d;
          d = e;
          if (e == '\0')
            return;
          int i = r.read();
          e = i < 0 ? '\0' : i == '\0' ? '_' : (char) i;
        } catch (Exception __e) {
          throw rethrow(__e);
        }
      }

      public void ncSave() {
        if (c != '\0') {
          buf.append(c);
          nc();
        }
      }

      public String next() {
        while (c != '\0') {
          if (c == ' ' || c == '\t' || c == '\r' || c == '\n')
            nc();
          else if (c == '/' && d == '*') {
            do nc(); while (c != '\0' && !(c == '*' && d == '/'));
            nc();
            nc();
          } else if (c == '/' && d == '/') {
            do nc(); while (c != '\0' && "\r\n".indexOf(c) < 0);
          } else
            break;
        }
        if (c == '\0')
          return null;
        if (c == '\'' || c == '"') {
          char opener = c;
          ncSave();
          while (c != '\0') {
            if (c == opener || c == '\n') {
              ncSave();
              break;
            } else if (c == '\\') {
              ncSave();
              ncSave();
            } else
              ncSave();
          }
        } else if (Character.isJavaIdentifierStart(c))
          do ncSave(); while (Character.isJavaIdentifierPart(c) || c == '\'');
        else if (Character.isDigit(c)) {
          do ncSave(); while (Character.isDigit(c));
          if (c == 'L')
            ncSave();
        } else
          ncSave();
        String t = buf.toString();
        buf.setLength(0);
        return t;
      }
    }
    return new X();
  }

  static public <A> Set<A> synchronizedSet() {
    return synchroHashSet();
  }

  static public <A> Set<A> synchronizedSet(Set<A> set) {
    return Collections.synchronizedSet(set);
  }

  static public Matcher regexpIC(Pattern pat, String s) {
    return pat.matcher(unnull(s));
  }

  static public Matcher regexpIC(String pat, String s) {
    return compileRegexpIC(pat).matcher(unnull(s));
  }

  static public Pattern regexpIC(String pat) {
    return compileRegexpIC(pat);
  }

  static public List<String> regexpGetGroups(Matcher matcher) {
    int n = matcher.groupCount();
    List<String> l = new ArrayList();
    for (int i = 1; i <= n; i++) l.add(matcher.group(i));
    return l;
  }

  static public List<String> regexpGetGroups(String pat, String s) {
    Matcher m = regexpMatcher(pat, s);
    if (m.find())
      return regexpGetGroups(m);
    return null;
  }

  static public TimeZone localTimeZone() {
    return getTimeZone(standardTimeZone());
  }

  static public int imageIcon_cacheSize = 10;

  static public boolean imageIcon_verbose = false;

  static public Map<String, ImageIcon> imageIcon_cache;

  static public Lock imageIcon_lock = lock();

  static public ThreadLocal<Boolean> imageIcon_fixGIF = new ThreadLocal();

  static public ImageIcon imageIcon(String imageID) {
    try {
      if (imageID == null)
        return null;
      Lock __0 = imageIcon_lock;
      lock(__0);
      try {
        if (imageIcon_cache == null)
          imageIcon_cache = new MRUCache(imageIcon_cacheSize);
        imageID = fsI(imageID);
        ImageIcon ii = imageIcon_cache.get(imageID);
        if (ii == null) {
          if (imageIcon_verbose)
            print("Loading image icon: " + imageID);
          File f = loadBinarySnippet(imageID);
          Boolean b = imageIcon_fixGIF.get();
          if (!isFalse(b))
            ii = new ImageIcon(loadBufferedImageFixingGIFs(f));
          else
            ii = new ImageIcon(f.toURI().toURL());
        } else
          imageIcon_cache.remove(imageID);
        imageIcon_cache.put(imageID, ii);
        return ii;
      } finally {
        unlock(__0);
      }
    } catch (Exception __e) {
      throw rethrow(__e);
    }
  }

  static public ImageIcon imageIcon(File f) {
    try {
      return new ImageIcon(f.toURI().toURL());
    } catch (Exception __e) {
      throw rethrow(__e);
    }
  }

  static public ImageIcon imageIcon(Image img) {
    return img == null ? null : new ImageIcon(img);
  }

  static public ImageIcon imageIcon(RGBImage img) {
    return imageIcon(img.getBufferedImage());
  }

  static public boolean charactersEqualIC(char c1, char c2) {
    if (c1 == c2)
      return true;
    char u1 = Character.toUpperCase(c1);
    char u2 = Character.toUpperCase(c2);
    if (u1 == u2)
      return true;
    return Character.toLowerCase(u1) == Character.toLowerCase(u2);
  }

  static public JPanel centerAndNorth(final Component c, final Component n) {
    return swing(new F0<JPanel>() {

      public JPanel get() {
        try {
          JPanel panel = new JPanel(new BorderLayout());
          panel.add(BorderLayout.CENTER, wrap(c));
          panel.add(BorderLayout.NORTH, wrap(n));
          return panel;
        } catch (Exception __e) {
          throw rethrow(__e);
        }
      }

      public String toString() {
        return "JPanel panel = new JPanel(new BorderLayout);\r\n    panel.add(BorderLayout.CENT...";
      }
    });
  }

  static public <A extends JLabel> A bindJLabelToVar(A label, IF0WithChangeListeners var) {
    bindListenerToComponent(label, var, () -> {
      try {
        setText(label, strOrNull(var.get()));
      } catch (Throwable e) {
        printStackTrace(e);
        setText(label, "Error");
      }
    });
    return label;
  }

  static public <A> List<A> childrenOfType(Component c, Class<A> theClass) {
    List<A> l = new ArrayList();
    scanForComponents(c, theClass, l);
    return l;
  }

  static public <A> List<A> childrenOfType(Class<A> theClass, Component c) {
    return childrenOfType(c, theClass);
  }

  static public void onFirstResize(final Component c, final Object r) {
    if (c != null && r != null) {
      swing(() -> {
        c.addComponentListener(new ComponentAdapter() {

          public void componentResized(ComponentEvent e) {
            c.removeComponentListener(this);
            pcallF(r);
          }
        });
      });
    }
  }

  static public void awtLater(int delay, final Object r) {
    swingLater(delay, r);
  }

  static public void awtLater(int delay, Runnable r) {
    swingLater(delay, r);
  }

  static public void awtLater(Object r) {
    swingLater(r);
  }

  static public void awtLater(double delaySeconds, Runnable r) {
    swingLater(toMS(delaySeconds), r);
  }

  static public void awtLater(JComponent component, int delay, Object r) {
    installTimer(component, r, delay, delay, false);
  }

  static public void awtLater(JFrame frame, int delay, Object r) {
    awtLater(frame.getRootPane(), delay, r);
  }

  static public String regexReplace(String s, String pat, Object f) {
    Matcher m = Pattern.compile(pat).matcher(s);
    return regexReplace(m, f);
  }

  static public String regexReplace(String s, String pat, String replacement) {
    return regexpReplace_direct(s, pat, replacement);
  }

  static public String regexReplace(Matcher m, Object f) {
    StringBuffer buf = new StringBuffer();
    while (m.find()) m.appendReplacement(buf, m.quoteReplacement(str(callF(f, m))));
    m.appendTail(buf);
    return str(buf);
  }

  static public String regexReplace(String s, String pat, IF1<Matcher, String> f) {
    return regexReplace(s, pat, (Object) f);
  }

  static public String regexpReplace_direct(String s, String pat, String replacement) {
    Matcher m = regexp(pat, s);
    return regexpReplace_direct(m, replacement);
  }

  static public String regexpReplace_direct(Matcher m, String replacement) {
    StringBuffer buf = new StringBuffer();
    while (m.find()) m.appendReplacement(buf, replacement);
    m.appendTail(buf);
    return str(buf);
  }

  static public boolean isCurlyBraced(String s) {
    List<String> tok = tok_combineCurlyBrackets_keep(javaTok(s));
    return l(tok) == 3 && startsWithAndEndsWith(tok.get(1), "{", "}");
  }

  static public String curlyBrace(String s) {
    return "{" + s + "}";
  }

  public static String rtrim(String s) {
    if (s == null)
      return null;
    int i = s.length();
    while (i > 0 && " \t\r\n".indexOf(s.charAt(i - 1)) >= 0) --i;
    return i < s.length() ? s.substring(0, i) : s;
  }

  static public List<String> filterNempty(Collection<String> c) {
    List<String> l = new ArrayList();
    for (String x : unnull(c)) if (nempty(x))
      l.add(x);
    return l;
  }

  static public IterableIterator<Integer> countIterator_inclusive(final int a, final int b) {
    return countIterator_exclusive(a, b + 1);
  }

  static public <A> IterableIterator<A> countIterator_inclusive(int a, int b, IF1<Integer, A> f) {
    return countIterator_inclusive(a, b, 1, f);
  }

  static public <A> IterableIterator<A> countIterator_inclusive(int a, int b, int step, IF1<Integer, A> f) {
    return countIterator_inclusive_step(a, b, 1, f);
  }

  static public <A> IterableIterator<A> countIterator_inclusive(double a, double b, double step, IF1<Double, A> f) {
    return countIterator_inclusive_step(a, b, step, f);
  }

  static public IterableIterator<Integer> countIterator_inclusive_step(int a, final int b, int step) {
    assertTrue("step > 0", step > 0);
    return new IterableIterator<Integer>() {

      public int i = a;

      public boolean hasNext() {
        return i <= b;
      }

      public Integer next() {
        var j = i;
        i += step;
        return j;
      }
    };
  }

  static public IterableIterator<Double> countIterator_inclusive_step(double a, double b, double step) {
    assertTrue("step > 0", step > 0);
    return new IterableIterator<Double>() {

      public double i = a;

      public boolean hasNext() {
        return i <= b;
      }

      public Double next() {
        var j = i;
        i += step;
        return j;
      }
    };
  }

  static public <A> IterableIterator<A> countIterator_inclusive_step(double a, double b, double step, IF1<Double, A> f) {
    return mapI_if1(f, countIterator_inclusive_step(a, b, step));
  }

  static public <A> IterableIterator<A> countIterator_inclusive_step(int a, int b, int step, IF1<Integer, A> f) {
    return mapI_if1(f, countIterator_inclusive_step(a, b, step));
  }

  static public boolean isURL(String s) {
    return startsWithOneOf(s, "http://", "https://", "file:");
  }

  static public BufferedImage imageIO_readURL(String url) {
    try {
      return ImageIO.read(new URL(url));
    } catch (Exception __e) {
      throw rethrow(__e);
    }
  }

  static public IResourceLoader vm_getResourceLoader() {
    return proxy(IResourceLoader.class, vm_generalMap_get("_officialResourceLoader"));
  }

  static public File imageSnippetsCacheDir() {
    return javaxCachesDir("Image-Snippets");
  }

  static public String snippetImageURL_http(String snippetID) {
    return snippetImageURL_http(snippetID, "png");
  }

  static public String snippetImageURL_http(String snippetID, String contentType) {
    return replacePrefix("https://", "http://", snippetImageURL(snippetID, contentType)).replace(":8443", ":8080");
  }

  static public BufferedImage loadBufferedImageFile(File file) {
    try {
      return isFile(file) ? ImageIO.read(file) : null;
    } catch (Exception __e) {
      throw rethrow(__e);
    }
  }

  static public void clickButton(final JButton b) {
    if (b != null) {
      swing(() -> {
        if (b.isEnabled())
          b.doClick();
      });
    }
  }

  static public void messageBox(final String msg) {
    print(msg);
    {
      swing(() -> {
        JOptionPane.showMessageDialog(null, msg, "JavaX", JOptionPane.INFORMATION_MESSAGE);
      });
    }
  }

  static public void messageBox(Throwable e) {
    printStackTrace(e);
    messageBox(hideCredentials(innerException2(e)));
  }

  static public KeyListener enterKeyListener(final Object action) {
    return new KeyAdapter() {

      public void keyPressed(KeyEvent ke) {
        if (ke.getKeyCode() == KeyEvent.VK_ENTER)
          pcallF(action);
      }
    };
  }

  static public Runnable rCallOnSelectedListItem(final JList list, final Object action) {
    return new Runnable() {

      public void run() {
        try {
          pcallF(action, getSelectedItem(list));
        } catch (Exception __e) {
          throw rethrow(__e);
        }
      }

      public String toString() {
        return "pcallF(action, getSelectedItem(list))";
      }
    };
  }

  static public AbstractAction abstractAction(String name, final Object runnable) {
    return new AbstractAction(name) {

      public void actionPerformed(ActionEvent evt) {
        pcallF(runnable);
      }
    };
  }

  static public ThreadLocal<List<Object>> holdInstance_l = new ThreadLocal();

  static public AutoCloseable holdInstance(Object o) {
    if (o == null)
      return null;
    listThreadLocalAdd(holdInstance_l, o);
    return new AutoCloseable() {

      public void close() {
        listThreadLocalPopLast(holdInstance_l);
      }
    };
  }

  static public List<Integer> countIteratorToList(int b) {
    return countIteratorToList(0, b);
  }

  static public List<Integer> countIteratorToList(int a, int b) {
    return asList(countIterator(a, b));
  }

  static public <A> List<A> countIteratorToList(int b, IF1<Integer, A> f) {
    return countIteratorToList(0, b, f);
  }

  static public <A> List<A> countIteratorToList(int a, int b, IF1<Integer, A> f) {
    return asList(countIterator(a, b, f));
  }

  static public List<Integer> countIteratorToList(int a, int b, int step) {
    return asList(countIterator(a, b, step));
  }

  static public <A> List<A> countIteratorToList(double a, double b, double step, IF1<Double, A> f) {
    return asList(countIterator(a, b, step, f));
  }

  static public <A> List<Double> countIteratorToList(double a, double b, double step) {
    return asList(countIterator(a, b, step));
  }

  static public <A> List<A> countIteratorToList(IF1<Double, A> f, double a, double b, double step) {
    return asList(countIterator(f, a, b, step));
  }

  static public <A> List<A> countIteratorToList(IF1<Integer, A> f, int b) {
    return countIteratorToList(f, 0, b);
  }

  static public <A> List<A> countIteratorToList(IF1<Integer, A> f, int a, int b) {
    return asList(countIterator(f, a, b));
  }

  static public <A> List<A> withoutNulls(Iterable<A> l) {
    if (l instanceof List)
      if (!containsNulls((List) l))
        return ((List) l);
    List<A> l2 = new ArrayList();
    for (A a : l) if (a != null)
      l2.add(a);
    return l2;
  }

  static public <A, B> Map<A, B> withoutNulls(Map<A, B> map) {
    Map<A, B> map2 = similarEmptyMap(map);
    for (A a : keys(map)) if (a != null) {
      B b = map.get(a);
      if (b != null)
        map2.put(a, b);
    }
    return map2;
  }

  static public <A> List<A> withoutNulls(A[] l) {
    List<A> l2 = new ArrayList();
    if (l != null)
      for (A a : l) if (a != null)
        l2.add(a);
    return l2;
  }

  static public IterableIterator<Integer> countIterator_exclusive(int b) {
    return countIterator_exclusive(0, b);
  }

  static public IterableIterator<Integer> countIterator_exclusive(int a, int b) {
    return new IterableIterator<Integer>() {

      public int i = a;

      public boolean hasNext() {
        return i < b;
      }

      public Integer next() {
        return i++;
      }
    };
  }

  static public <A> IterableIterator<A> countIterator_exclusive(int b, IF1<Integer, A> f) {
    return countIterator_exclusive(0, b, f);
  }

  static public <A> IterableIterator<A> countIterator_exclusive(int a, int b, IF1<Integer, A> f) {
    return mapI_if1(f, countIterator_exclusive(a, b));
  }

  static public IterableIterator<Integer> countIterator_exclusive_step(final int a, final int b, final int step) {
    assertTrue("step > 0", step > 0);
    return new IterableIterator<Integer>() {

      public int i = a;

      public boolean hasNext() {
        return i < b;
      }

      public Integer next() {
        var j = i;
        i += step;
        return j;
      }
    };
  }

  static public IterableIterator<Double> countIterator_exclusive_step(double a, double b, double step) {
    assertTrue("step > 0", step > 0);
    return new IterableIterator<Double>() {

      public double i = a;

      public boolean hasNext() {
        return i < b;
      }

      public Double next() {
        var j = i;
        i += step;
        return j;
      }
    };
  }

  static public <A> IterableIterator<A> countIterator_exclusive_step(double a, double b, double step, IF1<Double, A> f) {
    return mapI_if1(f, countIterator_exclusive_step(a, b, step));
  }

  static public Rect screenBounds(GraphicsDevice screen) {
    return screen == null ? null : toRect(screen.getDefaultConfiguration().getBounds());
  }

  static public Rect screenBounds(int iScreen) {
    return screenBounds(get(screenDevices(), iScreen));
  }

  static public int screenCount() {
    return l(GraphicsEnvironment.getLocalGraphicsEnvironment().getScreenDevices());
  }

  static public Rect boundsAsRect(Component c) {
    return boundsRect(c);
  }

  static public <A> int indexOfMax(List<A> l, IF1<A, Comparable> f) {
    Best_comparable<Integer> best = new Best_comparable();
    for (int i = 0; i < l(l); i++) best.put(i, f.get(l.get(i)));
    return or(best.get(), -1);
  }

  static public List<Rect> allScreenBounds() {
    return map(__80 -> screenBounds(__80), screenDevices());
  }

  static public int area(Rect r) {
    return rectArea(r);
  }

  static public double area(DoubleRect r) {
    return r == null ? 0 : r.w * r.h;
  }

  static public int area(WidthAndHeight img) {
    return img == null ? 0 : img.getWidth() * img.getHeight();
  }

  static public Rect intersectRects(Rect a, Rect b) {
    int x = max(a.x, b.x), y = max(a.y, b.y);
    int x2 = min(a.x + a.w, b.x + b.w), y2 = min(a.y + a.h, b.y + b.h);
    return new Rect(x, y, x2 - x, y2 - y);
  }

  static public Rect intersectRects(Rect a, int x1, int y1, int w, int h) {
    if (a == null || a.x >= x1 && a.y >= y1 && a.x2() < x1 + w && a.y2() < y1 + h)
      return a;
    return rectFromPoints(max(a.x, x1), max(a.y, y1), min(a.x2(), x1 + w), min(a.y2(), y1 + h));
  }

  static public int[] subIntArray(int[] b, int start) {
    return subIntArray(b, start, l(b));
  }

  static public int[] subIntArray(int[] b, int start, int end) {
    start = max(start, 0);
    end = min(end, l(b));
    if (start == 0 && end == l(b))
      return b;
    if (start >= end)
      return new int[0];
    int[] x = new int[end - start];
    System.arraycopy(b, start, x, 0, end - start);
    return x;
  }

  static public int[] subIntArray(int[] a, IntRange r) {
    return r == null ? null : subIntArray(a, r.start, r.end);
  }

  static public short[] subShortArray(short[] b, int start, int end) {
    start = max(start, 0);
    end = min(end, l(b));
    if (start == 0 && end == l(b))
      return b;
    if (start >= end)
      return new short[0];
    short[] x = new short[end - start];
    System.arraycopy(b, start, x, 0, end - start);
    return x;
  }

  static public byte[] subByteArray(byte[] b, int start) {
    return subByteArray(b, start, l(b));
  }

  static public byte[] subByteArray(byte[] b, int start, int end) {
    start = max(start, 0);
    end = min(end, l(b));
    if (start == 0 && end == l(b))
      return b;
    if (start >= end)
      return new byte[0];
    byte[] x = new byte[end - start];
    System.arraycopy(b, start, x, 0, end - start);
    return x;
  }

  static public byte[] subByteArray(byte[] b, IntRange r) {
    return r == null ? null : subByteArray(b, r.start, r.end);
  }

  static public double[] subDoubleArray(double[] b, int start) {
    return subDoubleArray(b, start, l(b));
  }

  static public double[] subDoubleArray(double[] b, int start, int end) {
    start = max(start, 0);
    end = min(end, l(b));
    if (start == 0 && end == l(b))
      return b;
    if (start >= end)
      return new double[0];
    double[] x = new double[end - start];
    System.arraycopy(b, start, x, 0, end - start);
    return x;
  }

  static public <A> List<A> sortByCalculatedField(Iterable<A> c, final Object f) {
    List<A> l = cloneList(c);
    sort(l, new Comparator<A>() {

      public int compare(A a, A b) {
        return stdcompare(callF(f, a), callF(f, b));
      }
    });
    return l;
  }

  static public int stdcompare(Number a, Number b) {
    return cmp(a, b);
  }

  static public int stdcompare(String a, String b) {
    return cmp(a, b);
  }

  static public int stdcompare(long a, long b) {
    return a < b ? -1 : a > b ? 1 : 0;
  }

  static public int stdcompare(Object a, Object b) {
    return cmp(a, b);
  }

  static public IterableIterator<String> lines_iterator(final String s) {
    if (s == null)
      return emptyIterableIterator();
    return iteratorFromFunction(new F0<String>() {

      public int start = 0;

      public String get() {
        int i = toLines_nextLineBreak(s, start);
        if (i < 0) {
          String toReturn = s.length() > start ? s.substring(start) : null;
          start = s.length();
          return toReturn;
        }
        String toReturn = s.substring(start, i);
        if (s.charAt(i) == '\r' && i + 1 < s.length() && s.charAt(i + 1) == '\n')
          i += 2;
        else
          ++i;
        start = i;
        return toReturn;
      }
    });
  }

  static public <A, B> Map<A, B> weakHashMap() {
    return newWeakHashMap();
  }

  static public Set emptySet() {
    return new HashSet();
  }

  static public <A> TreeSet<A> asTreeSet(Collection<A> set) {
    return set == null ? null : set instanceof TreeSet ? (TreeSet) set : new TreeSet(set);
  }

  static public class getOpt_Map extends WeakHashMap {

    public getOpt_Map() {
      if (getOpt_special == null)
        getOpt_special = new HashMap();
      clear();
    }

    public void clear() {
      super.clear();
      put(Class.class, getOpt_special);
      put(String.class, getOpt_special);
    }
  }

  static final public Map<Class, HashMap<String, Field>> getOpt_cache = _registerDangerousWeakMap(synchroMap(new getOpt_Map()));

  static public HashMap getOpt_special;

  static public Map<String, Field> getOpt_getFieldMap(Object o) {
    Class c = _getClass(o);
    HashMap<String, Field> map = getOpt_cache.get(c);
    if (map == null)
      map = getOpt_makeCache(c);
    return map;
  }

  static public Object getOpt_cached(Object o, String field) {
    try {
      if (o == null)
        return null;
      Map<String, Field> map = getOpt_getFieldMap(o);
      if (map == getOpt_special) {
        if (o instanceof Class)
          return getOpt((Class) o, field);
        if (o instanceof Map)
          return ((Map) o).get(field);
      }
      Field f = map.get(field);
      if (f != null)
        return f.get(o);
      if (o instanceof DynamicObject)
        return syncMapGet2(((DynamicObject) o).fieldValues, field);
      return null;
    } catch (Exception __e) {
      throw rethrow(__e);
    }
  }

  static public HashMap<String, Field> getOpt_makeCache(Class c) {
    HashMap<String, Field> map;
    if (isSubtypeOf(c, Map.class))
      map = getOpt_special;
    else {
      map = new HashMap();
      if (!reflection_classesNotToScan().contains(c.getName())) {
        Class _c = c;
        do {
          for (Field f : _c.getDeclaredFields()) {
            makeAccessible(f);
            String name = f.getName();
            if (!map.containsKey(name))
              map.put(name, f);
          }
          _c = _c.getSuperclass();
        } while (_c != null);
      }
    }
    if (getOpt_cache != null)
      getOpt_cache.put(c, map);
    return map;
  }

  static public TreeSet<String> litciset(String... items) {
    TreeSet<String> set = caseInsensitiveSet();
    for (String a : items) set.add(a);
    return set;
  }

  static public TreeSet<Symbol> litciset(Symbol... items) {
    TreeSet<Symbol> set = treeSet();
    for (Symbol a : items) set.add(a);
    return set;
  }

  static public String afterLastSpace(String s) {
    return s == null ? null : substring(s, s.lastIndexOf(' ') + 1);
  }

  static public String dropSuffixIgnoreCase(String suffix, String s) {
    return ewic(s, suffix) ? s.substring(0, l(s) - l(suffix)) : s;
  }

  static public boolean ewicOneOf(String s, String... l) {
    if (s != null)
      for (String x : l) if (ewic(s, x))
        return true;
    return false;
  }

  static public <A extends JComponent> A addMargin(final int top, final int left, final int bottom, final int right, final A c) {
    if (c != null) {
      swing(() -> {
        Border margin = BorderFactory.createEmptyBorder(top, left, bottom, right);
        c.setBorder(jCompoundBorder(c.getBorder(), margin));
      });
    }
    return c;
  }

  static public <A extends JComponent> A addMargin(int w, A c) {
    return addMargin(w, w, w, w, c);
  }

  static public <A extends Component> A jMinWidth_pure(int w, A c) {
    {
      swing(() -> {
        Dimension size = c.getMinimumSize();
        c.setMinimumSize(new Dimension(w, size.height));
      });
    }
    return c;
  }

  static public <A extends Component> A jMinWidth_pure(A c, int w) {
    return jMinWidth_pure(w, c);
  }

  static public Object[] asObjectArray(Collection l) {
    return toObjectArray(l);
  }

  static public JTextArea enableWordWrapForTextArea(JTextArea ta) {
    return enableWordWrapForTextArea(ta, true);
  }

  static public JTextArea enableWordWrapForTextArea(JTextArea ta, boolean enabled) {
    if (ta != null) {
      swing(() -> {
        ta.setLineWrap(enabled);
        ta.setWrapStyleWord(true);
      });
    }
    return ta;
  }

  static public JTextArea jtextarea() {
    return jTextArea();
  }

  static public JTextArea jtextarea(String text) {
    return jTextArea(text);
  }

  static public <A extends JComponent> A setFont(final Font font, final A a) {
    if (a != null) {
      swing(() -> {
        a.setFont(font);
      });
    }
    return a;
  }

  static public <A extends JComponent> A setFont(A a, Font font) {
    return setFont(font, a);
  }

  static public <A extends JComponent> A setFont(final String fontID, float fontSize, final A a) {
    return setFont(loadFont_cached(fontID, fontSize), a);
  }

  static public void clearTabs(final JTabbedPane tabs) {
    if (tabs != null) {
      swing(() -> {
        tabs.removeAll();
      });
    }
  }

  static public int asInt(Object o) {
    return toInt(o);
  }

  static public boolean isComponentOrSwingable(Object o) {
    if (o instanceof Swingable)
      return true;
    return o instanceof Component;
  }

  static public void addTab(JTabbedPane tabs, String title) {
    addTab(tabs, title, jpanel());
  }

  static public void addTab(JTabbedPane tabs, String title, Component c) {
    if (tabs != null) {
      swing(() -> {
        tabs.add(title, wrap(c));
      });
    }
  }

  static public void addTab(JTabbedPane tabs, String title, Swingable c) {
    if (tabs != null) {
      swing(() -> {
        tabs.add(title, wrap(c));
      });
    }
  }

  static public void addTab(JTabbedPane tabs, WithToolTip<String> title, Component c) {
    addTabWithToolTip(tabs, title.toolTip(), title == null ? null : title.get(), c);
  }

  static public void addTab(JTabbedPane tabs, WithToolTip<String> title, Swingable c) {
    addTabWithToolTip(tabs, title.toolTip(), title == null ? null : title.get(), c);
  }

  static public void addTabWithToolTip(JTabbedPane tabs, String title, String toolTip, Component c) {
    if (tabs == null)
      return;
    {
      swing(() -> {
        addTab(tabs, title, c);
        if (nempty(toolTip))
          tabs.setToolTipTextAt(tabCount(tabs) - 1, toolTip);
      });
    }
  }

  static public void addTabWithToolTip(JTabbedPane tabs, String title, String toolTip, Swingable c) {
    addTabWithToolTip(tabs, title, toolTip, wrap(c));
  }

  static public MenuItem menuItem(String text, final Object r) {
    MenuItem mi = new MenuItem(text);
    mi.addActionListener(actionListener(r));
    return mi;
  }

  static public void addDirectMenuItem(JMenuBar mb, String text, Object action) {
    if (mb != null) {
      swing(() -> {
        addDirectMenuItem(mb, directJMenuItem(text, action));
      });
    }
  }

  static public void addDirectMenuItem(Component c, String text, Object action) {
    addDirectMenuItem(addMenuBar(c), text, action);
  }

  static public void addDirectMenuItem(JMenuBar mb, JMenuItem menuItem) {
    if (mb != null) {
      swing(() -> {
        mb.add(menuItem);
        revalidate(mb);
      });
    }
  }

  static public TreeMap revTreeMap() {
    return new TreeMap(reverseComparator());
  }

  static public int indexOfIC_underscore(String a, String b) {
    int la = l(a), lb = l(b);
    if (la < lb)
      return -1;
    int n = la - lb;
    elsewhere: for (int i = 0; i <= n; i++) {
      for (int j = 0; j < lb; j++) {
        char c2 = b.charAt(j);
        if (c2 == '_' || eqic(c2, a.charAt(i + j))) {
        } else
          continue elsewhere;
      }
      return i;
    }
    return -1;
  }

  static public <A, B> List<B> lambdaMap(IF1<A, B> f, Iterable<A> l) {
    return map(l, f);
  }

  static public <A, B> List<B> lambdaMap(IF1<A, B> f, A[] l) {
    return map(l, f);
  }

  static public <A, B> B secondOfPair(Pair<A, B> p) {
    return p == null ? null : p.b;
  }

  static public Map<JFrame, Boolean> myFrames_list = weakHashMap();

  static public List<JFrame> myFrames() {
    return swing(new F0<List<JFrame>>() {

      public List<JFrame> get() {
        try {
          return keysList(myFrames_list);
        } catch (Exception __e) {
          throw rethrow(__e);
        }
      }

      public String toString() {
        return "return keysList(myFrames_list);";
      }
    });
  }

  static public <A> IterableIterator<A> iteratorFromFunction_withEndMarker_f0(final F0<A> f) {
    class IFF2 extends IterableIterator<A> {

      public A a;

      public boolean have, done;

      public boolean hasNext() {
        getNext();
        return !done;
      }

      public A next() {
        getNext();
        if (done)
          throw fail();
        A _a = a;
        a = null;
        have = false;
        return _a;
      }

      public void getNext() {
        if (done || have)
          return;
        Object o = f.get();
        if (o == iteratorFromFunction_endMarker) {
          done = true;
          return;
        }
        a = (A) o;
        have = true;
      }
    }
    ;
    return new IFF2();
  }

  static public boolean isTrueOpt(Object o) {
    if (o instanceof Boolean)
      return ((Boolean) o).booleanValue();
    return false;
  }

  static public boolean isTrueOpt(String field, Object o) {
    return isTrueOpt(getOpt(field, o));
  }

  static public boolean eqicOneOf(String s, String... l) {
    for (String x : l) if (eqic(s, x))
      return true;
    return false;
  }

  static public List<String> isYes_yesses = litlist("y", "yes", "yeah", "y", "yup", "yo", "corect", "sure", "ok", "afirmative");

  static public boolean isYes(String s) {
    return isYes_yesses.contains(collapseWord(toLowerCase(firstWord2(s))));
  }

  static public <A> List<A> wrapArrayAsList(A[] a) {
    return a == null ? null : Arrays.asList(a);
  }

  static public String htmlencode2(String s) {
    return htmlencode_noQuotes(s);
  }

  static public void setOptIfNotNull(Object o, String field, Object value) {
    if (value != null)
      setOpt(o, field, value);
  }

  static public Object mainBot;

  static public Object getMainBot() {
    return mainBot;
  }

  static public Object[] mapToParams(Map map) {
    return mapToObjectArray(map);
  }

  static public Object[] unrollParams(Object[] params) {
    if (l(params) == 1 && params[0] instanceof Map)
      return mapToParams((Map) params[0]);
    return params;
  }

  static public Object html_valueLessParam_cache;

  static public Object html_valueLessParam() {
    if (html_valueLessParam_cache == null)
      html_valueLessParam_cache = html_valueLessParam_load();
    return html_valueLessParam_cache;
  }

  static public Object html_valueLessParam_load() {
    return new Object();
  }

  static public String htmlQuote(String s) {
    return "\"" + htmlencode_forParams(s) + "\"";
  }

  static public boolean neqic(String a, String b) {
    return !eqic(a, b);
  }

  static public boolean neqic(char a, char b) {
    return !eqic(a, b);
  }

  static public ThreadLocal<Random> customRandomizerForThisThread_tl = new ThreadLocal();

  static public ThreadLocal<Random> customRandomizerForThisThread_tl() {
    return customRandomizerForThisThread_tl;
  }

  static public BufferedImage drawImage(BufferedImage canvas, Image img, Pt p) {
    return drawImageOnImage(img, canvas, p.x, p.y);
  }

  static public void drawImage(BufferedImage g, Image img) {
    drawImage(graphics(g), img);
  }

  static public void drawImage(Graphics2D g, Image img) {
    drawImage(g, img, 0, 0);
  }

  static public void drawImage(Graphics2D g, Image img, Pt p) {
    drawImage(g, img, p.x, p.y);
  }

  static public void drawImage(Graphics2D g, Image img, int x, int y) {
    {
      if (g != null)
        g.drawImage(img, x, y, null);
    }
  }

  static public Object callJavaX(String method, Object... args) {
    return callOpt(getJavaX(), method, args);
  }

  static public CloseableIterableIterator emptyCloseableIterableIterator_instance = new CloseableIterableIterator() {

    public Object next() {
      throw fail();
    }

    public boolean hasNext() {
      return false;
    }
  };

  static public <A> CloseableIterableIterator<A> emptyCloseableIterableIterator() {
    return emptyCloseableIterableIterator_instance;
  }

  static public CloseableIterableIterator<String> linesFromReader(Reader r) {
    return linesFromReader(r, null);
  }

  static public CloseableIterableIterator<String> linesFromReader(Reader r, IResourceHolder resourceHolder) {
    final BufferedReader br = bufferedReader(r);
    return holdResource(resourceHolder, iteratorFromFunction_f0_autoCloseable(new F0<String>() {

      public String get() {
        try {
          return readLineFromReaderWithClose(br);
        } catch (Exception __e) {
          throw rethrow(__e);
        }
      }

      public String toString() {
        return "return readLineFromReaderWithClose(br);";
      }
    }, _wrapIOCloseable(r)));
  }

  static public BufferedReader utf8bufferedReader(InputStream in) {
    try {
      return in == null ? null : bufferedReader(_registerIOWrap(new InputStreamReader(in, "UTF-8"), in));
    } catch (Exception __e) {
      throw rethrow(__e);
    }
  }

  static public BufferedReader utf8bufferedReader(File f) {
    try {
      return utf8bufferedReader(newFileInputStream(f));
    } catch (Exception __e) {
      throw rethrow(__e);
    }
  }

  static public Set<String> listFields(Object c) {
    TreeSet<String> fields = new TreeSet();
    for (Field f : _getClass(c).getDeclaredFields()) fields.add(f.getName());
    return fields;
  }

  static public boolean instanceOf(Object o, String className) {
    if (o == null)
      return false;
    String c = o.getClass().getName();
    return eq(c, className) || eq(c, "main$" + className);
  }

  static public boolean instanceOf(Object o, Class c) {
    if (c == null)
      return false;
    return c.isInstance(o);
  }

  static public boolean instanceOf(Class c, Object o) {
    return instanceOf(o, c);
  }

  static public boolean eqicOrEq(Object a, Object b) {
    return a instanceof String && b instanceof String ? eqic((String) a, (String) b) : eq(a, b);
  }

  static public Object deref(Object o) {
    if (o instanceof IRef)
      return ((IRef) o).get();
    return o;
  }

  static public Comparator makeComparator(final Object f) {
    if (f instanceof Comparator)
      return (Comparator) f;
    return new Comparator() {

      public int compare(Object a, Object b) {
        return (Integer) callF(f, a, b);
      }
    };
  }

  static public Throwable printStackTrace2(Throwable e) {
    print(getStackTrace2(e));
    return e;
  }

  static public void printStackTrace2() {
    printStackTrace2(new Throwable());
  }

  static public void printStackTrace2(String msg) {
    printStackTrace2(new Throwable(msg));
  }

  static public Throwable innerException(Throwable e) {
    return getInnerException(e);
  }

  static public Map vm_generalSubMap(Object name) {
    synchronized (vm_generalMap()) {
      Map map = (Map) (vm_generalMap_get(name));
      if (map == null)
        vm_generalMap_put(name, map = synchroMap());
      return map;
    }
  }

  static public <A> Set<A> synchroWeakHashSet() {
    return Collections.newSetFromMap((Map) newWeakHashMap());
  }

  static public <A> AutoCloseable tempSetThreadLocalIfNecessary(ThreadLocal<A> tl, A a) {
    if (tl == null)
      return null;
    A prev = tl.get();
    if (eq(prev, a))
      return null;
    tl.set(a);
    return new AutoCloseable() {

      public String toString() {
        return "tl.set(prev);";
      }

      public void close() throws Exception {
        tl.set(prev);
      }
    };
  }

  static public <A> AutoCloseable tempSetThreadLocalIfNecessary(BetterThreadLocal<A> tl, A a) {
    if (tl == null)
      return null;
    A prev = tl.get();
    if (eq(prev, a))
      return null;
    tl.set(a);
    return new AutoCloseable() {

      public String toString() {
        return "tl.set(prev);";
      }

      public void close() throws Exception {
        tl.set(prev);
      }
    };
  }

  static public AutoCloseable tempUncancelThread() {
    return tempRemove(ping_actions, Thread.currentThread());
  }

  static public <A> boolean setAdd(Collection<A> c, A a) {
    if (c == null || c.contains(a))
      return false;
    c.add(a);
    return true;
  }

  static public <A> A[] typedArray(Class<A> c, int n) {
    return (A[]) Array.newInstance(c, n);
  }

  static public int typeConversionScore(Class a, Class b) {
    if (a == b)
      return 0;
    if (b.isPrimitive()) {
      if (a.isPrimitive()) {
        if (b == boolean.class)
          return Integer.MAX_VALUE;
        if (b == byte.class)
          return Integer.MAX_VALUE;
        if (b == char.class)
          return a == byte.class ? -2 : Integer.MAX_VALUE;
        if (b == short.class)
          return a == byte.class ? -2 : Integer.MAX_VALUE;
        if (b == int.class)
          return a == byte.class || a == char.class || a == short.class ? -2 : Integer.MAX_VALUE;
        if (b == long.class)
          return a == byte.class || a == char.class || a == short.class || a == int.class ? -2 : Integer.MAX_VALUE;
        if (b == float.class)
          return a == byte.class || a == char.class || a == short.class || a == int.class ? -2 : Integer.MAX_VALUE;
        return a != boolean.class ? -2 : Integer.MAX_VALUE;
      } else {
        return primitiveToBoxedType(b) == a ? 1 : Integer.MAX_VALUE;
      }
    } else {
      if (a.isPrimitive())
        return primitiveToBoxedType(a) == b ? 1 : Integer.MAX_VALUE;
      return b.isAssignableFrom(a) ? 1 : Integer.MAX_VALUE;
    }
  }

  static public Class boxedToPrimitiveType(Class type) {
    if (type == Boolean.class)
      return boolean.class;
    if (type == Integer.class)
      return int.class;
    if (type == Long.class)
      return long.class;
    if (type == Float.class)
      return float.class;
    if (type == Short.class)
      return short.class;
    if (type == Character.class)
      return char.class;
    if (type == Byte.class)
      return byte.class;
    if (type == Double.class)
      return double.class;
    return null;
  }

  static public boolean isSubclass(Class a, Class b) {
    return a != null && b != null && b.isAssignableFrom(a);
  }

  static public String getSelectedItem(JList l) {
    return (String) l.getSelectedValue();
  }

  static public String getSelectedItem(JComboBox cb) {
    return strOrNull(cb.getSelectedItem());
  }

  static public boolean zipFileContains(File inZip, String fileName) {
    try {
      ZipFile zip = new ZipFile(inZip);
      try {
        return zipFileContains(zip, fileName);
      } finally {
        zip.close();
      }
    } catch (Exception __e) {
      throw rethrow(__e);
    }
  }

  static public boolean zipFileContains(ZipFile zip, String fileName) {
    try {
      return zip.getEntry(fileName) != null;
    } catch (Exception __e) {
      throw rethrow(__e);
    }
  }

  static public File envJavaHome() {
    return newFile(System.getProperty("java.home"));
  }

  static public void setDynObjectValue(DynamicObject o, String field, Object value) {
    dynamicObject_setRawFieldValue(o, field, value);
  }

  static public betterCIComparator_C betterCIComparator_instance;

  static public betterCIComparator_C betterCIComparator() {
    if (betterCIComparator_instance == null)
      betterCIComparator_instance = new betterCIComparator_C();
    return betterCIComparator_instance;
  }

  final static public class betterCIComparator_C implements Comparator<String> {

    public int compare(String s1, String s2) {
      if (s1 == null)
        return s2 == null ? 0 : -1;
      if (s2 == null)
        return 1;
      int n1 = s1.length();
      int n2 = s2.length();
      int min = Math.min(n1, n2);
      for (int i = 0; i < min; i++) {
        char c1 = s1.charAt(i);
        char c2 = s2.charAt(i);
        if (c1 != c2) {
          c1 = Character.toUpperCase(c1);
          c2 = Character.toUpperCase(c2);
          if (c1 != c2) {
            c1 = Character.toLowerCase(c1);
            c2 = Character.toLowerCase(c2);
            if (c1 != c2) {
              return c1 - c2;
            }
          }
        }
      }
      return n1 - n2;
    }
  }

  static public AlphanumComparator alphaNumComparator_instance;

  static public Comparator<String> alphaNumComparator() {
    if (alphaNumComparator_instance == null)
      alphaNumComparator_instance = new AlphanumComparator();
    return alphaNumComparator_instance;
  }

  static public void logQuotedWithTime(String s) {
    logQuotedWithTime(standardLogFile(), s);
  }

  static public void logQuotedWithTime(File logFile, String s) {
    logQuoted(logFile, logQuotedWithTime_format(s));
  }

  static public void logQuotedWithTime(String logFile, String s) {
    logQuoted(logFile, logQuotedWithTime_format(s));
  }

  static public String logQuotedWithTime_format(String s) {
    return (now()) + " " + s;
  }

  static public <A extends JComponent> A onClick(A c, IVF1<MouseEvent> runnable) {
    return onClick(c, (Object) runnable);
  }

  static public <A extends JComponent> A onClick(A c, Object runnable) {
    if (c != null) {
      swing(() -> {
        c.addMouseListener(new MouseAdapter() {

          public void mouseClicked(MouseEvent e) {
            callF(runnable, e);
          }
        });
      });
    }
    return c;
  }

  static public void onClick(JButton btn, Object runnable) {
    onEnter(btn, runnable);
  }

  static public void disposeWindow(final Window window) {
    if (window != null) {
      swing(() -> {
        window.dispatchEvent(new WindowEvent(window, WindowEvent.WINDOW_CLOSING));
        myFrames_list.remove(window);
        window.dispose();
      });
    }
  }

  static public void disposeWindow(final Component c) {
    disposeWindow(getWindow(c));
  }

  static public void disposeWindow(Object o) {
    if (o != null)
      disposeWindow(((Component) o));
  }

  static public void disposeWindow() {
    disposeWindow(heldInstance(Component.class));
  }

  static public Rect preferredScreenBounds() {
    return screenBounds_safe(preferredScreen());
  }

  static public boolean vmBus_anyFalse(String msg, Object... args) {
    return contains(vmBus_queryAll(msg, args), false);
  }

  static public Runnable asRunnable(Object o) {
    return toRunnable(o);
  }

  static public void _inheritThreadInfo(Object info) {
    _threadInheritInfo(info);
  }

  static public boolean hasMethod(Object o, String method, Object... args) {
    return findMethod_cached(o, method, args) != null;
  }

  static public JMenuItem jMenuItem(final String text) {
    return jmenuItem(text);
  }

  static public JMenuItem jMenuItem(String text, Object r) {
    return jmenuItem(text, r);
  }

  static public Pair<String, Integer> jmenu_autoMnemonic(String s) {
    int i = indexOf(s, '&');
    if (i >= 0 && i < l(s) && isLetterOrDigit(s.charAt(i + 1)))
      return pair(substring(s, 0, i) + substring(s, i + 1), (int) s.charAt(i + 1));
    return pair(s, 0);
  }

  static public JMenuItem disableMenuItem(final JMenuItem mi) {
    if (mi != null) {
      swing(() -> {
        mi.setEnabled(false);
      });
    }
    return mi;
  }

  static public ActionListener actionListenerInNewThread(final Object runnable) {
    return actionListenerInNewThread(runnable, null);
  }

  static public ActionListener actionListenerInNewThread(final Object runnable, final Object instanceToHold) {
    if (runnable instanceof ActionListener)
      return (ActionListener) runnable;
    return new java.awt.event.ActionListener() {

      public void actionPerformed(java.awt.event.ActionEvent _evt) {
        try {
          startThread("Action Listener", new Runnable() {

            public void run() {
              try {
                AutoCloseable __1 = holdInstance(instanceToHold);
                try {
                  callF(runnable);
                } finally {
                  _close(__1);
                }
              } catch (Exception __e) {
                throw rethrow(__e);
              }
            }

            public String toString() {
              return "AutoCloseable __1 = holdInstance(instanceToHold); try {\r\n      callF(runnable...";
            }
          });
        } catch (Throwable __e) {
          messageBox(__e);
        }
      }
    };
  }

  static public String tok_unCurlyBracket(String s) {
    return isCurlyBraced(s) ? join(dropFirstThreeAndLastThree(javaTok(s))) : s;
  }

  static public <A extends JComponent> A bindHasChangeListenersToComponent(A component, IHasChangeListeners hcl, Runnable listener) {
    if (hcl != null)
      bindToComponent(component, () -> hcl.onChangeAndNow(listener), () -> hcl.removeChangeListener(listener));
    return component;
  }

  static public void setCaret(final JTextComponent c, final int pos) {
    if (c != null) {
      swing(() -> {
        c.setCaretPosition(pos);
      });
    }
  }

  static public float getSwingFontScale() {
    return or((Float) vm_generalMap_get("swingFontScale_value"), 1f);
  }

  static public void setMeta(IMeta o, Object key, Object value) {
    metaMapPut(o, key, value);
  }

  static public void setMeta(Object o, Object key, Object value) {
    metaMapPut(o, key, value);
  }

  static public AutoCloseable tempActivity(Object r) {
    return null;
  }

  static public boolean allPaused() {
    return ping_pauseAll;
  }

  static public void bindTimerToComponent(final Timer timer, JFrame f) {
    bindTimerToComponent(timer, f.getRootPane());
  }

  static public void bindTimerToComponent(final Timer timer, JComponent c) {
    if (c.isShowing())
      timer.start();
    c.addAncestorListener(new AncestorListener() {

      public void ancestorAdded(AncestorEvent event) {
        timer.start();
      }

      public void ancestorRemoved(AncestorEvent event) {
        timer.stop();
      }

      public void ancestorMoved(AncestorEvent event) {
      }
    });
  }

  static public RootPaneContainer getPossiblyInternalFrame(Component c) {
    JInternalFrame f = getInternalFrame(c);
    if (f != null)
      return f;
    return optCast(RootPaneContainer.class, getWindow(c));
  }

  static public JButton jimageButton(String imageID, Object action) {
    JButton btn = jbutton("", action);
    btn.setIcon(imageIcon(imageID));
    return btn;
  }

  static public JButton jimageButton(String imageID) {
    return jimageButton(imageID, null);
  }

  static public JButton jimageButton(Image img) {
    return jimageButton(img, null, null);
  }

  static public JButton jimageButton(String imageID, String toolTip, Runnable action) {
    return jimageButton(imageIcon(imageID), toolTip, action);
  }

  static public JButton jimageButton(Image img, String toolTip, Runnable action) {
    var btn = jbutton("", action);
    setButtonImage(btn, img);
    return setToolTip(toolTip, btn);
  }

  static public JButton jimageButton(ImageIcon img, String toolTip, Runnable action) {
    var btn = jbutton("", action);
    setButtonImage(btn, img);
    return setToolTip(toolTip, btn);
  }

  static public BufferedImage scaleImageToWidth(BufferedImage img, int newW) {
    return resizeImage(img, newW);
  }

  static public BufferedImage scaleImageToWidth(int newW, BufferedImage img) {
    return scaleImageToWidth(img, newW);
  }

  static public BufferedImage scaleImageToWidth(int newW, String imageID) {
    return scaleImageToWidth(newW, loadImage2(imageID));
  }

  static public String renderStackTrace(StackTraceElement[] st) {
    return stackTraceToString(st);
  }

  static public String renderStackTrace(Throwable e) {
    return stackTraceToString(e);
  }

  static public String renderStackTrace(String msg) {
    return renderStackTrace(new Throwable(msg));
  }

  static public boolean boolPar(ThreadLocal<Boolean> tl) {
    return boolOptParam(tl);
  }

  static public boolean boolPar(Object[] __, String name) {
    return boolOptParam(__, name);
  }

  static public boolean boolPar(String name, Object[] __) {
    return boolOptParam(__, name);
  }

  static public boolean boolPar(String name, Map __) {
    return boolOptParam(name, __);
  }

  static public boolean boolPar(String name, Object[] params, boolean defaultValue) {
    return optParam(params, name, defaultValue);
  }

  public static boolean isWindows() {
    return System.getProperty("os.name").contains("Windows");
  }

  static public List<AbstractButton> buttonsInGroup(ButtonGroup g) {
    if (g == null)
      return ll();
    return asList(g.getElements());
  }

  static public JTextArea jTextAreaWithUndo() {
    return jTextAreaWithUndo("");
  }

  static public JTextArea jTextAreaWithUndo(final String text) {
    return jenableUndoRedo(swingNu(JTextArea.class, text));
  }

  static public String getProgramName_cache;

  static public String getProgramName() {
    Lock __0 = downloadLock();
    lock(__0);
    try {
      if (getProgramName_cache == null)
        getProgramName_cache = getSnippetTitleOpt(programID());
      return getProgramName_cache;
    } finally {
      unlock(__0);
    }
  }

  static public void _onLoad_getProgramName() {
    {
      startThread(new Runnable() {

        public void run() {
          try {
            getProgramName();
          } catch (Exception __e) {
            throw rethrow(__e);
          }
        }

        public String toString() {
          return "getProgramName();";
        }
      });
    }
  }

  static public void standardTitlePopupMenu(final JFrame frame) {
    if (!isSubstanceLAF())
      return;
    titlePopupMenu(frame, new VF1<JPopupMenu>() {

      public void get(JPopupMenu menu) {
        try {
          boolean alwaysOnTop = frame.isAlwaysOnTop();
          menu.add(jmenuItem("Restart Program", new Runnable() {

            public void run() {
              try {
                restart();
              } catch (Exception __e) {
                throw rethrow(__e);
              }
            }

            public String toString() {
              return "restart();";
            }
          }));
          menu.add(jmenuItem("Duplicate Program", new Runnable() {

            public void run() {
              try {
                duplicateThisProgram();
              } catch (Exception __e) {
                throw rethrow(__e);
              }
            }

            public String toString() {
              return "duplicateThisProgram();";
            }
          }));
          menu.add(jmenuItem("Show Console", new Runnable() {

            public void run() {
              try {
                showConsole();
              } catch (Exception __e) {
                throw rethrow(__e);
              }
            }

            public String toString() {
              return "showConsole();";
            }
          }));
          menu.add(jCheckBoxMenuItem("Always On Top", alwaysOnTop, new Runnable() {

            public void run() {
              try {
                toggleAlwaysOnTop(frame);
              } catch (Exception __e) {
                throw rethrow(__e);
              }
            }

            public String toString() {
              return "toggleAlwaysOnTop(frame)";
            }
          }));
        } catch (Exception __e) {
          throw rethrow(__e);
        }
      }

      public String toString() {
        return "bool alwaysOnTop = frame.isAlwaysOnTop();\r\n    ifndef standardTitlePopupMenu_...";
      }
    });
  }

  static public Integer centerX(Rect r) {
    return rectCenterX(r);
  }

  static public Integer centerY(Rect r) {
    return rectCenterY(r);
  }

  static public JFrame consoleFrame() {
    return (JFrame) getOpt(get(getJavaX(), "console"), "frame");
  }

  static public void autoVMExit() {
    call(getJavaX(), "autoVMExit");
  }

  static public boolean isCIMap(Map m) {
    return m instanceof TreeMap && ((TreeMap) m).comparator() == caseInsensitiveComparator();
  }

  static public <A> TreeMap<String, A> ciMap() {
    return caseInsensitiveMap();
  }

  static public int gzInputStream_defaultBufferSize = 65536;

  static public GZIPInputStream gzInputStream(File f) {
    try {
      return gzInputStream(new FileInputStream(f));
    } catch (Exception __e) {
      throw rethrow(__e);
    }
  }

  static public GZIPInputStream gzInputStream(File f, int bufferSize) {
    try {
      return gzInputStream(new FileInputStream(f), bufferSize);
    } catch (Exception __e) {
      throw rethrow(__e);
    }
  }

  static public GZIPInputStream gzInputStream(InputStream in) {
    return gzInputStream(in, gzInputStream_defaultBufferSize);
  }

  static public GZIPInputStream gzInputStream(InputStream in, int bufferSize) {
    try {
      return _registerIOWrap(new GZIPInputStream(in, gzInputStream_defaultBufferSize), in);
    } catch (Exception __e) {
      throw rethrow(__e);
    }
  }

  static public Producer<String> javaTokC_noMLS_iterator(final String s) {
    return javaTokC_noMLS_iterator(s, 0);
  }

  static public Producer<String> javaTokC_noMLS_iterator(final String s, final int startIndex) {
    return new Producer<String>() {

      final public int l = s.length();

      public int i = startIndex;

      public String next() {
        if (i >= l)
          return null;
        int j = i;
        char c, d;
        while (j < l) {
          c = s.charAt(j);
          d = j + 1 >= l ? '\0' : s.charAt(j + 1);
          if (c == ' ' || c == '\t' || c == '\r' || c == '\n')
            ++j;
          else if (c == '/' && d == '*') {
            do ++j; while (j < l && !s.substring(j, Math.min(j + 2, l)).equals("*/"));
            j = Math.min(j + 2, l);
          } else if (c == '/' && d == '/') {
            do ++j; while (j < l && "\r\n".indexOf(s.charAt(j)) < 0);
          } else
            break;
        }
        i = j;
        if (i >= l)
          return null;
        c = s.charAt(i);
        d = i + 1 >= l ? '\0' : s.charAt(i + 1);
        if (c == '\'' || c == '"') {
          char opener = c;
          ++j;
          while (j < l) {
            if (s.charAt(j) == opener || s.charAt(j) == '\n') {
              ++j;
              break;
            } else if (s.charAt(j) == '\\' && j + 1 < l)
              j += 2;
            else
              ++j;
          }
        } else if (Character.isJavaIdentifierStart(c))
          do ++j; while (j < l && Character.isJavaIdentifierPart(s.charAt(j)));
        else if (Character.isDigit(c)) {
          do ++j; while (j < l && Character.isDigit(s.charAt(j)));
          if (j < l && s.charAt(j) == 'L')
            ++j;
        } else
          ++j;
        String t = quickSubstring(s, i, j);
        i = j;
        return t;
      }
    };
  }

  static public String actualMCDollar() {
    return actualMC().getName() + "$";
  }

  static public BigInteger parseBigInt(String s) {
    return new BigInteger(s);
  }

  static public String unquoteUsingCharArray(String s, char[] buf) {
    if (s == null)
      return null;
    if (startsWith(s, '[')) {
      int i = 1;
      while (i < s.length() && s.charAt(i) == '=') ++i;
      if (i < s.length() && s.charAt(i) == '[') {
        String m = s.substring(1, i);
        if (s.endsWith("]" + m + "]"))
          return s.substring(i + 1, s.length() - i - 1);
      }
    }
    if (s.length() > 1) {
      char c = s.charAt(0);
      if (c == '\"' || c == '\'') {
        int l = endsWith(s, c) ? s.length() - 1 : s.length();
        if (l > buf.length)
          return unquote(s);
        int n = 0;
        for (int i = 1; i < l; i++) {
          char ch = s.charAt(i);
          if (ch == '\\') {
            char nextChar = (i == l - 1) ? '\\' : s.charAt(i + 1);
            if (nextChar >= '0' && nextChar <= '7') {
              String code = "" + nextChar;
              i++;
              if ((i < l - 1) && s.charAt(i + 1) >= '0' && s.charAt(i + 1) <= '7') {
                code += s.charAt(i + 1);
                i++;
                if ((i < l - 1) && s.charAt(i + 1) >= '0' && s.charAt(i + 1) <= '7') {
                  code += s.charAt(i + 1);
                  i++;
                }
              }
              buf[n++] = (char) Integer.parseInt(code, 8);
              continue;
            }
            switch(nextChar) {
              case '\"':
                ch = '\"';
                break;
              case '\\':
                ch = '\\';
                break;
              case 'b':
                ch = '\b';
                break;
              case 'f':
                ch = '\f';
                break;
              case 'n':
                ch = '\n';
                break;
              case 'r':
                ch = '\r';
                break;
              case 't':
                ch = '\t';
                break;
              case '\'':
                ch = '\'';
                break;
              case 'u':
                if (i >= l - 5) {
                  ch = 'u';
                  break;
                }
                int code = Integer.parseInt("" + s.charAt(i + 2) + s.charAt(i + 3) + s.charAt(i + 4) + s.charAt(i + 5), 16);
                char[] x = Character.toChars(code);
                int lx = x.length;
                for (int j = 0; j < lx; j++) buf[n++] = x[j];
                i += 5;
                continue;
              default:
                ch = nextChar;
            }
            i++;
          }
          buf[n++] = ch;
        }
        return new String(buf, 0, n);
      }
    }
    return s;
  }

  static public boolean structure_isMarker(String s, int i, int j) {
    if (i >= j)
      return false;
    if (s.charAt(i) != 'm')
      return false;
    ++i;
    while (i < j) {
      char c = s.charAt(i);
      if (c < '0' || c > '9')
        return false;
      ++i;
    }
    return true;
  }

  static public String internIfLongerThan(String s, int l) {
    return s == null ? null : l(s) >= l ? intern(s) : s;
  }

  static public char unquoteCharacter(String s) {
    assertTrue(s.startsWith("'") && s.length() > 1);
    return unquote("\"" + s.substring(1, s.endsWith("'") ? s.length() - 1 : s.length()) + "\"").charAt(0);
  }

  static public boolean isLongConstant(String s) {
    if (!s.endsWith("L"))
      return false;
    s = s.substring(0, l(s) - 1);
    return isInteger(s);
  }

  static public List parseList(String s) {
    return (List) safeUnstructure(s);
  }

  static public <A> List<A> synchroLinkedList() {
    return synchroList(new LinkedList<A>());
  }

  static public <A, B> NavigableMap<A, B> synchroNavigableMap(NavigableMap<A, B> map) {
    return Collections.synchronizedNavigableMap(map);
  }

  static public <A, B> SortedMap<A, B> synchroSortedMap(SortedMap<A, B> map) {
    return Collections.synchronizedSortedMap(map);
  }

  static public byte[] hexToBytes(String s) {
    if (odd(l(s)))
      throw fail("Hex string has odd length: " + quote(shorten(10, s)));
    int n = l(s) / 2;
    byte[] bytes = new byte[n];
    for (int i = 0; i < n; i++) {
      int a = parseHexChar(s.charAt(i * 2));
      int b = parseHexChar(s.charAt(i * 2 + 1));
      if (a < 0 || b < 0)
        throw fail("Bad hex byte: " + quote(substring(s, i * 2, i * 2 + 2)) + " at " + i * 2 + "/" + l(s));
      bytes[i] = (byte) ((a << 4) | b);
    }
    return bytes;
  }

  static public boolean[] boolArrayFromBytes(byte[] a, int n) {
    boolean[] b = new boolean[n];
    int m = min(n, l(a) * 8);
    for (int i = 0; i < m; i++) b[i] = (a[i / 8] & 1 << (i & 7)) != 0;
    return b;
  }

  static public <A> Constructor nuStubInnerObject_findConstructor(Class<A> c) {
    return nuStubInnerObject_findConstructor(c, null);
  }

  static public <A> Constructor nuStubInnerObject_findConstructor(Class<A> c, Object classFinder) {
    try {
      Class outerType = getOuterClass(c, classFinder);
      Constructor m = c.getDeclaredConstructor(outerType);
      makeAccessible(m);
      return m;
    } catch (Exception __e) {
      throw rethrow(__e);
    }
  }

  static public Map<Class, Constructor> nuEmptyObject_cache = newDangerousWeakHashMap();

  static public <A> A nuEmptyObject(Class<A> c) {
    try {
      Constructor ctr;
      synchronized (nuEmptyObject_cache) {
        ctr = nuEmptyObject_cache.get(c);
        if (ctr == null) {
          nuEmptyObject_cache.put(c, ctr = nuEmptyObject_findConstructor(c));
          makeAccessible(ctr);
        }
      }
      try {
        return (A) ctr.newInstance();
      } catch (InstantiationException e) {
        if (empty(e.getMessage()))
          if ((c.getModifiers() & Modifier.ABSTRACT) != 0)
            throw fail("Can't instantiate abstract class " + className(c), e);
          else
            throw fail("Can't instantiate " + className(c), e);
        else
          throw rethrow(e);
      }
    } catch (Exception __e) {
      throw rethrow(__e);
    }
  }

  static public Constructor nuEmptyObject_findConstructor(Class c) {
    for (Constructor m : getDeclaredConstructors_cached(c)) if (m.getParameterTypes().length == 0)
      return m;
    throw fail("No default constructor declared in " + c.getName());
  }

  static public void setOptAllDyn_pcall(DynamicObject o, Map<String, Object> fields) {
    if (fields == null || o == null)
      return;
    HashMap<String, Field> fieldMap = instanceFieldsMap(o);
    for (Map.Entry<String, Object> e : fields.entrySet()) {
      try {
        String field = e.getKey();
        Object val = e.getValue();
        Field f = fieldMap.get(field);
        if (f != null)
          smartSet(f, o, val);
        else {
          dynamicObject_setRawFieldValue(o, intern(field), val);
        }
      } catch (Throwable __e) {
        printStackTrace(__e);
      }
    }
  }

  static public void setOptAll_pcall(Object o, Map<String, Object> fields) {
    if (fields == null)
      return;
    for (String field : keys(fields)) try {
      setOpt(o, field, fields.get(field));
    } catch (Throwable __e) {
      print(exceptionToStringShort(__e));
    }
  }

  static public void setOptAll_pcall(Object o, Object... values) {
    warnIfOddCount(values);
    for (int i = 0; i + 1 < l(values); i += 2) {
      String field = (String) values[i];
      Object value = values[i + 1];
      try {
        setOpt(o, field, value);
      } catch (Throwable __e) {
        print(exceptionToStringShort(__e));
      }
    }
  }

  static public void fixOuterRefs(Object o) {
    try {
      if (o == null)
        return;
      Field[] l = thisDollarOneFields(o.getClass());
      if (l.length <= 1)
        return;
      Object father = null;
      for (Field f : l) {
        father = f.get(o);
        if (father != null)
          break;
      }
      if (father == null)
        return;
      for (Field f : l) f.set(o, father);
    } catch (Exception __e) {
      throw rethrow(__e);
    }
  }

  static public String intern(String s) {
    return fastIntern(s);
  }

  static public void pcallOpt_noArgs(Object o, String method) {
    try {
      callOpt_noArgs(o, method);
    } catch (Throwable __e) {
      printStackTrace(__e);
    }
  }

  static public RuntimeException todo() {
    throw new RuntimeException("TODO");
  }

  static public RuntimeException todo(Object msg) {
    throw new RuntimeException("TODO: " + msg);
  }

  static public Object newMultiDimensionalOuterArray(Class elementType, int dimensions, int length) {
    int[] dims = new int[dimensions];
    dims[0] = length;
    return Array.newInstance(elementType, dims);
  }

  static public int[] toIntArray(Collection<Integer> l) {
    int[] a = new int[l(l)];
    int i = 0;
    if (a.length != 0)
      for (int x : l) a[i++] = x;
    return a;
  }

  static public double[] toDoubleArray(Collection<Double> l) {
    double[] a = new double[l(l)];
    int i = 0;
    if (a.length != 0)
      for (double x : l) a[i++] = x;
    return a;
  }

  static public TreeSet<String> ciSet() {
    return caseInsensitiveSet();
  }

  static public boolean jmatch(String pat, String s) {
    return jmatch(pat, s, null);
  }

  static public boolean jmatch(String pat, String s, Matches matches) {
    if (s == null)
      return false;
    return jmatch(pat, javaTok(s), matches);
  }

  static public boolean jmatch(String pat, List<String> toks) {
    return jmatch(pat, toks, null);
  }

  static public boolean jmatch(String pat, List<String> toks, Matches matches) {
    List<String> tokpat = javaTok(pat);
    String[] m = match2(tokpat, toks);
    if (m == null)
      return false;
    else {
      if (matches != null)
        matches.m = m;
      return true;
    }
  }

  static public <A> A popLast(List<A> l) {
    return liftLast(l);
  }

  static public <A> List<A> popLast(int n, List<A> l) {
    return liftLast(n, l);
  }

  static public Map<String, java.util.regex.Pattern> compileRegexpIC_cache = syncMRUCache(10);

  static public java.util.regex.Pattern compileRegexpIC(String pat) {
    java.util.regex.Pattern p = compileRegexpIC_cache.get(pat);
    if (p == null) {
      try {
        compileRegexpIC_cache.put(pat, p = java.util.regex.Pattern.compile(pat, Pattern.CASE_INSENSITIVE));
      } catch (PatternSyntaxException e) {
        throw rethrow(wrapPatternSyntaxException(e));
      }
    }
    return p;
  }

  static public Matcher regexpMatcher(String pat, String s) {
    return compileRegexp(pat).matcher(unnull(s));
  }

  static public Matcher regexpMatcher(java.util.regex.Pattern pat, String s) {
    return pat.matcher(unnull(s));
  }

  static public TimeZone getTimeZone(String name) {
    return TimeZone.getTimeZone(name);
  }

  static public String standardTimeZone_name = "Europe/Berlin";

  static public String standardTimeZone() {
    return standardTimeZone_name;
  }

  static public String fsI(String id) {
    return formatSnippetID(id);
  }

  static public String fsI(long id) {
    return formatSnippetID(id);
  }

  static public File loadBinarySnippet(String snippetID) {
    IResourceLoader rl = vm_getResourceLoader();
    if (rl != null)
      return rl.loadLibrary(snippetID);
    return loadBinarySnippet_noResourceLoader(snippetID);
  }

  static public File loadBinarySnippet_noResourceLoader(String snippetID) {
    try {
      long id = parseSnippetID(snippetID);
      if (isImageServerSnippet(id))
        return loadImageAsFile(snippetID);
      File f = DiskSnippetCache_getLibrary(id);
      if (fileSize(f) == 0)
        f = loadDataSnippetToFile_noResourceLoader(snippetID);
      return f;
    } catch (Exception __e) {
      throw rethrow(__e);
    }
  }

  static public boolean loadBufferedImageFixingGIFs_debug = false;

  static public ThreadLocal<Var<byte[]>> loadBufferedImageFixingGIFs_output = new ThreadLocal();

  static public Image loadBufferedImageFixingGIFs(File file) {
    try {
      if (!file.exists())
        return null;
      if (!isGIF(file))
        return ImageIO.read(file);
      if (loadBufferedImageFixingGIFs_debug)
        print("loadBufferedImageFixingGIFs" + ": checking gif");
      ImageReader reader = ImageIO.getImageReadersByFormatName("gif").next();
      reader.setInput(ImageIO.createImageInputStream(file));
      int numImages = reader.getNumImages(true);
      IIOMetadata imageMetaData = reader.getImageMetadata(0);
      String metaFormatName = imageMetaData.getNativeMetadataFormatName();
      boolean foundBug = false;
      for (int i = 0; i < numImages && !foundBug; i++) {
        IIOMetadataNode root = (IIOMetadataNode) reader.getImageMetadata(i).getAsTree(metaFormatName);
        int nNodes = root.getLength();
        for (int j = 0; j < nNodes; j++) {
          org.w3c.dom.Node node = root.item(j);
          if (node.getNodeName().equalsIgnoreCase("GraphicControlExtension")) {
            String delay = ((IIOMetadataNode) node).getAttribute("delayTime");
            if (Integer.parseInt(delay) == 0) {
              foundBug = true;
            }
            break;
          }
        }
      }
      if (loadBufferedImageFixingGIFs_debug)
        print("loadBufferedImageFixingGIFs" + ": " + f2s(file) + " foundBug=" + foundBug);
      Image image;
      if (!foundBug) {
        image = Toolkit.getDefaultToolkit().createImage(f2s(file));
      } else {
        ByteArrayOutputStream baoStream = new ByteArrayOutputStream();
        {
          ImageOutputStream ios = ImageIO.createImageOutputStream(baoStream);
          try {
            ImageWriter writer = ImageIO.getImageWriter(reader);
            writer.setOutput(ios);
            writer.prepareWriteSequence(null);
            for (int i = 0; i < numImages; i++) {
              BufferedImage frameIn = reader.read(i);
              IIOMetadataNode root = (IIOMetadataNode) reader.getImageMetadata(i).getAsTree(metaFormatName);
              int nNodes = root.getLength();
              for (int j = 0; j < nNodes; j++) {
                org.w3c.dom.Node node = root.item(j);
                if (node.getNodeName().equalsIgnoreCase("GraphicControlExtension")) {
                  String delay = ((IIOMetadataNode) node).getAttribute("delayTime");
                  if (Integer.parseInt(delay) == 0) {
                    ((IIOMetadataNode) node).setAttribute("delayTime", "10");
                  }
                  break;
                }
              }
              IIOMetadata metadata = writer.getDefaultImageMetadata(new ImageTypeSpecifier(frameIn), null);
              metadata.setFromTree(metadata.getNativeMetadataFormatName(), root);
              IIOImage frameOut = new IIOImage(frameIn, null, metadata);
              writer.writeToSequence(frameOut, writer.getDefaultWriteParam());
            }
            writer.endWriteSequence();
          } finally {
            _close(ios);
          }
        }
        byte[] data = baoStream.toByteArray();
        setVar(loadBufferedImageFixingGIFs_output.get(), data);
        if (loadBufferedImageFixingGIFs_debug)
          print("Data size: " + l(data));
        image = Toolkit.getDefaultToolkit().createImage(data);
      }
      return image;
    } catch (Exception __e) {
      throw rethrow(__e);
    }
  }

  static public <A extends JComponent> A bindListenerToComponent(A component, IHasChangeListeners source, Runnable listener) {
    if (source != null && listener != null)
      bindToComponent(component, new Runnable() {

        public void run() {
          try {
            source.onChangeAndNow(listener);
          } catch (Exception __e) {
            throw rethrow(__e);
          }
        }

        public String toString() {
          return "source.onChangeAndNow(listener);";
        }
      }, new Runnable() {

        public void run() {
          try {
            source.removeChangeListener(listener);
          } catch (Exception __e) {
            throw rethrow(__e);
          }
        }

        public String toString() {
          return "source.removeChangeListener(listener)";
        }
      });
    return component;
  }

  static public <A> void scanForComponents(final Component c, final Class<A> theClass, final List<A> l) {
    if (theClass.isInstance(c))
      l.add((A) c);
    if (c instanceof Container) {
      swing(() -> {
        for (Component comp : ((Container) c).getComponents()) scanForComponents(comp, theClass, l);
      });
    }
  }

  static public Matcher regexp(String pat, String s) {
    return regexp(compileRegexp(pat), unnull(s));
  }

  static public Matcher regexp(java.util.regex.Pattern pat, String s) {
    return pat.matcher(unnull(s));
  }

  static public java.util.regex.Pattern regexp(String pat) {
    return compileRegexp(pat);
  }

  static public List<String> tok_combineCurlyBrackets_keep(List<String> tok) {
    List<String> l = new ArrayList();
    for (int i = 0; i < l(tok); i++) {
      String t = tok.get(i);
      if (odd(i) && eq(t, "{")) {
        int j = findEndOfCurlyBracketPart(tok, i);
        l.add(joinSubList(tok, i, j));
        i = j - 1;
      } else
        l.add(t);
    }
    return l;
  }

  static public boolean startsWithAndEndsWith(String s, String prefix, String suffix) {
    return startsWith(s, prefix) && endsWith(s, suffix);
  }

  static public class mapI_if1_It<A, B> extends IterableIterator<B> {

    public IF1<A, B> f;

    public Iterator<A> i;

    public mapI_if1_It() {
    }

    public mapI_if1_It(IF1<A, B> f, Iterator<A> i) {
      this.i = i;
      this.f = f;
    }

    public boolean hasNext() {
      return i.hasNext();
    }

    public B next() {
      return f.get(i.next());
    }

    public String toString() {
      return formatFunctionCall("mapI_if1", f, i);
    }
  }

  static public <A, B> IterableIterator<B> mapI_if1(IF1<A, B> f, Iterable<A> i) {
    return new mapI_if1_It(f, i.iterator());
  }

  static public <A, B> IterableIterator<B> mapI_if1(Iterable<A> i, IF1<A, B> f) {
    return mapI_if1(f, i);
  }

  static public <A> A proxy(Class<A> intrface, final Object target) {
    if (target == null)
      return null;
    if (isInstance(intrface, target))
      return (A) target;
    return (A) java.lang.reflect.Proxy.newProxyInstance(intrface.getClassLoader(), new Class[] { intrface }, new proxy_InvocationHandler(target));
  }

  static public <A> A proxy(Object target, Class<A> intrface) {
    return proxy(intrface, target);
  }

  static public File javaxCachesDir_dir;

  static public File javaxCachesDir() {
    return javaxCachesDir_dir != null ? javaxCachesDir_dir : new File(userHome(), "JavaX-Caches");
  }

  static public File javaxCachesDir(String sub) {
    return newFile(javaxCachesDir(), sub);
  }

  static public String snippetImageURL(long snippetID) {
    return snippetImageURL(fsI(snippetID));
  }

  static public String snippetImageURL(String snippetID) {
    return snippetImageURL(snippetID, "png");
  }

  static public String snippetImageURL(String snippetID, String contentType) {
    if (snippetID == null || isURL(snippetID))
      return snippetID;
    long id = parseSnippetID(snippetID);
    String url;
    if (isImageServerSnippet(id))
      url = imageServerLink(id);
    else
      url = "https://botcompany.de/img/" + id;
    return url;
  }

  static public Throwable innerException2(Throwable e) {
    if (e == null)
      return null;
    while (empty(e.getMessage()) && e.getCause() != null) e = e.getCause();
    return e;
  }

  static public <A> void listThreadLocalAdd(ThreadLocal<List<A>> tl, A a) {
    List<A> l = tl.get();
    if (l == null)
      tl.set(l = new ArrayList());
    l.add(a);
  }

  static public <A> A listThreadLocalPopLast(ThreadLocal<List<A>> tl) {
    List<A> l = tl.get();
    if (l == null)
      return null;
    A a = popLast(l);
    if (empty(l))
      tl.set(null);
    return a;
  }

  static public boolean containsNulls(Collection c) {
    return contains(c, null);
  }

  static public Map similarEmptyMap(Map m) {
    if (m instanceof TreeMap)
      return new TreeMap(((TreeMap) m).comparator());
    if (m instanceof LinkedHashMap)
      return new LinkedHashMap();
    return new HashMap();
  }

  static public Map similarEmptyMap(Iterable m) {
    if (m instanceof TreeSet)
      return new TreeMap(((TreeSet) m).comparator());
    if (m instanceof LinkedHashSet)
      return new LinkedHashMap();
    return new HashMap();
  }

  static public List<GraphicsDevice> screenDevices() {
    return asList(GraphicsEnvironment.getLocalGraphicsEnvironment().getScreenDevices());
  }

  static public Rect boundsRect(Component c) {
    return toRect(getBounds(c));
  }

  static public int rectArea(Rect r) {
    return r == null ? 0 : r.w * r.h;
  }

  static public Rect rectFromPoints(int x1, int y1, int x2, int y2) {
    return pointsRect(x1, y1, x2, y2);
  }

  static public Rect rectFromPoints(Pt a, Pt b) {
    return pointsRect(a.x, a.y, b.x, b.y);
  }

  static public <A> IterableIterator<A> iteratorFromFunction(final Object f) {
    class IFF extends IterableIterator<A> {

      public A a;

      public boolean done = false;

      public boolean hasNext() {
        getNext();
        return !done;
      }

      public A next() {
        getNext();
        if (done)
          throw fail();
        A _a = a;
        a = null;
        return _a;
      }

      public void getNext() {
        if (done || a != null)
          return;
        a = (A) callF(f);
        done = a == null;
      }
    }
    ;
    return new IFF();
  }

  static public <A> IterableIterator<A> iteratorFromFunction(F0<A> f) {
    return iteratorFromFunction_f0(f);
  }

  static public <A> IterableIterator<A> iteratorFromFunction(IF0<A> f) {
    return iteratorFromFunction_if0(f);
  }

  static public List<Pair> _registerDangerousWeakMap_preList;

  static public <A> A _registerDangerousWeakMap(A map) {
    return _registerDangerousWeakMap(map, null);
  }

  static public <A> A _registerDangerousWeakMap(A map, Object init) {
    callF(init, map);
    if (init instanceof String) {
      final String f = (String) init;
      init = new VF1<Map>() {

        public void get(Map map) {
          try {
            callMC(f, map);
          } catch (Exception __e) {
            throw rethrow(__e);
          }
        }

        public String toString() {
          return "callMC(f, map)";
        }
      };
    }
    if (javax() == null) {
      if (_registerDangerousWeakMap_preList == null)
        _registerDangerousWeakMap_preList = synchroList();
      _registerDangerousWeakMap_preList.add(pair(map, init));
      return map;
    }
    call(javax(), "_registerDangerousWeakMap", map, init);
    return map;
  }

  static public void _onLoad_registerDangerousWeakMap() {
    assertNotNull(javax());
    if (_registerDangerousWeakMap_preList == null)
      return;
    for (Pair p : _registerDangerousWeakMap_preList) _registerDangerousWeakMap(p.a, p.b);
    _registerDangerousWeakMap_preList = null;
  }

  static public <A, B> B syncMapGet2(Map<A, B> map, A a) {
    if (map == null)
      return null;
    synchronized (collectionMutex(map)) {
      return map.get(a);
    }
  }

  static public <A, B> B syncMapGet2(A a, Map<A, B> map) {
    return syncMapGet2(map, a);
  }

  static public boolean isSubtypeOf(Class a, Class b) {
    return a != null && b != null && b.isAssignableFrom(a);
  }

  static public Set<String> reflection_classesNotToScan_value = litset("jdk.internal.loader.URLClassPath");

  static public Set<String> reflection_classesNotToScan() {
    return reflection_classesNotToScan_value;
  }

  static public TreeSet<String> caseInsensitiveSet() {
    return caseInsensitiveSet_treeSet();
  }

  static public TreeSet<String> caseInsensitiveSet(Collection<String> c) {
    return caseInsensitiveSet_treeSet(c);
  }

  static public <A> TreeSet<A> treeSet() {
    return new TreeSet();
  }

  static public Border jCompoundBorder(Border inner, Border outer) {
    if (inner == null)
      return outer;
    if (outer == null)
      return inner;
    return BorderFactory.createCompoundBorder(inner, outer);
  }

  static public Map<String, Font> loadFont_cached_cache = new HashMap();

  static synchronized public Font loadFont_cached(String snippetID) {
    try {
      snippetID = formatSnippetID(snippetID);
      Font f = loadFont_cached_cache.get(snippetID);
      if (f == null)
        loadFont_cached_cache.put(snippetID, f = loadFont(snippetID, 12f));
      return f;
    } catch (Exception __e) {
      throw rethrow(__e);
    }
  }

  static synchronized public Font loadFont_cached(String snippetID, float size) {
    try {
      return loadFont_cached(snippetID).deriveFont(size);
    } catch (Exception __e) {
      throw rethrow(__e);
    }
  }

  static public int tabCount(JTabbedPane tabs) {
    return tabs == null ? 0 : swing(() -> tabs.getTabCount());
  }

  static public JMenuItem directJMenuItem(Action a) {
    return new JMenuItem(a) {

      public Dimension getMaximumSize() {
        return new Dimension(super.getPreferredSize().width, super.getMaximumSize().height);
      }
    };
  }

  static public JMenuItem directJMenuItem(String text, Object action) {
    return directJMenuItem(abstractAction(text, action));
  }

  static public JMenuBar addMenuBar(final Component c) {
    return swing(new F0<JMenuBar>() {

      public JMenuBar get() {
        try {
          RootPaneContainer f = getPossiblyInternalFrame(c);
          if (f == null)
            return null;
          JMenuBar bar = (JMenuBar) (call(f, "getJMenuBar"));
          if (bar == null) {
            setMenuBar(f, bar = new JMenuBar());
            revalidate((Component) f);
          }
          return bar;
        } catch (Exception __e) {
          throw rethrow(__e);
        }
      }

      public String toString() {
        return "RootPaneContainer f = getPossiblyInternalFrame(c);\r\n    if (f == null) null;\r...";
      }
    });
  }

  static public <A> Comparator<A> reverseComparator(Comparator<A> c) {
    return (a, b) -> c.compare(b, a);
  }

  static public <A> Comparator<A> reverseComparator() {
    return (a, b) -> cmp(b, a);
  }

  static public <A, B> List<A> keysList(Map<A, B> map) {
    return cloneListSynchronizingOn(keys(map), map);
  }

  static public <A> List<A> keysList(MultiSet<A> ms) {
    return ms == null ? null : keysList(ms.map);
  }

  static public List<String> toLowerCase(List<String> strings) {
    List<String> x = new ArrayList();
    for (String s : strings) x.add(s.toLowerCase());
    return x;
  }

  static public String[] toLowerCase(String[] strings) {
    String[] x = new String[l(strings)];
    for (int i = 0; i < l(strings); i++) x[i] = strings[i].toLowerCase();
    return x;
  }

  static public String toLowerCase(String s) {
    return s == null ? "" : s.toLowerCase();
  }

  static public String firstWord2(String s) {
    s = xltrim(s);
    if (empty(s))
      return "";
    if (isLetterOrDigit(first(s)))
      return takeCharsWhile(__81 -> isLetterOrDigit(__81), s);
    else
      return "" + first(s);
  }

  static public String htmlencode_noQuotes(String s) {
    if (s == null)
      return "";
    int n = s.length();
    StringBuilder out = null;
    for (int i = 0; i < n; i++) {
      char c = s.charAt(i);
      if (c == '<') {
        if (out == null)
          out = new StringBuilder(Math.max(16, n)).append(takeFirst(i, s));
        out.append("&lt;");
      } else if (c == '>') {
        if (out == null)
          out = new StringBuilder(Math.max(16, n)).append(takeFirst(i, s));
        out.append("&gt;");
      } else if (c > 127 || c == '&') {
        int cp = s.codePointAt(i);
        if (out == null)
          out = new StringBuilder(Math.max(16, n)).append(takeFirst(i, s));
        out.append("&#x");
        out.append(intToHex_flexLength(cp));
        out.append(';');
        i += Character.charCount(cp) - 1;
      } else {
        if (out != null)
          out.append(c);
      }
    }
    return out == null ? s : out.toString();
  }

  static public Object[] mapToObjectArray(Map map) {
    List l = new ArrayList();
    for (Object o : keys(map)) {
      l.add(o);
      l.add(map.get(o));
    }
    return toObjectArray(l);
  }

  static public Object[] mapToObjectArray(Object f, Collection l) {
    int n = l(l);
    Object[] array = new Object[n];
    if (n != 0) {
      Iterator it = iterator(l);
      for (int i = 0; i < n; i++) array[i] = callF(f, it.next());
    }
    return array;
  }

  static public Object[] mapToObjectArray(Object f, Object[] l) {
    int n = l(l);
    Object[] array = new Object[n];
    for (int i = 0; i < n; i++) array[i] = callF(f, l[i]);
    return array;
  }

  static public <A> Object[] mapToObjectArray(Collection<A> l, IF1<A, Object> f) {
    return mapToObjectArray(f, l);
  }

  static public <A> Object[] mapToObjectArray(A[] l, IF1<A, Object> f) {
    return mapToObjectArray(f, l);
  }

  static public <A> Object[] mapToObjectArray(IF1<A, Object> f, A[] l) {
    int n = l(l);
    Object[] array = new Object[n];
    for (int i = 0; i < n; i++) array[i] = f.get(l[i]);
    return array;
  }

  static public <A> Object[] mapToObjectArray(IF1<A, Object> f, Collection<A> l) {
    int n = l(l);
    Object[] array = new Object[n];
    if (n != 0) {
      Iterator it = iterator(l);
      for (int i = 0; i < n; i++) array[i] = callF(f, it.next());
    }
    return array;
  }

  static public ThreadLocal<Boolean> htmlencode_forParams_useV2 = new ThreadLocal();

  static public String htmlencode_forParams(String s) {
    if (s == null)
      return "";
    if (isTrue(htmlencode_forParams_useV2.get()))
      return htmlencode_forParams_v2(s);
    StringBuilder out = new StringBuilder(Math.max(16, s.length()));
    for (int i = 0; i < s.length(); i++) {
      char c = s.charAt(i);
      if (c > 127 || c == '"' || c == '<' || c == '>') {
        out.append("&#");
        out.append((int) c);
        out.append(';');
      } else
        out.append(c);
    }
    return out.toString();
  }

  static public BufferedImage drawImageOnImage(Image img, BufferedImage canvas, int x, int y) {
    createGraphics(canvas).drawImage(img, x, y, null);
    return canvas;
  }

  static public BufferedImage drawImageOnImage(Image img, BufferedImage canvas) {
    return drawImageOnImage(img, canvas, 0, 0);
  }

  static public Graphics2D graphics(BufferedImage img) {
    return imageGraphics(img);
  }

  static public BufferedReader bufferedReader(Reader r) {
    return bufferedReader(r, 8192);
  }

  static public BufferedReader bufferedReader(Reader r, int bufSize) {
    if (r == null)
      return null;
    return r instanceof BufferedReader ? (BufferedReader) r : _registerIOWrap(new BufferedReader(r, bufSize), r);
  }

  static public <A extends AutoCloseable> A holdResource(IResourceHolder holder, A a) {
    {
      if (holder != null)
        holder.add(a);
    }
    return a;
  }

  static public <A> CloseableIterableIterator<A> iteratorFromFunction_f0_autoCloseable(final F0<A> f, final AutoCloseable closeable) {
    class IFF2 extends CloseableIterableIterator<A> {

      public A a;

      public boolean done = false;

      public boolean hasNext() {
        getNext();
        return !done;
      }

      public A next() {
        getNext();
        if (done)
          throw fail();
        A _a = a;
        a = null;
        return _a;
      }

      public void getNext() {
        if (done || a != null)
          return;
        a = f.get();
        done = a == null;
      }

      public void close() throws Exception {
        if (closeable != null)
          closeable.close();
      }
    }
    ;
    return new IFF2();
  }

  static public String readLineFromReaderWithClose(BufferedReader r) {
    try {
      String s = r.readLine();
      if (s == null)
        r.close();
      return s;
    } catch (Exception __e) {
      throw rethrow(__e);
    }
  }

  static public AutoCloseable _wrapIOCloseable(final AutoCloseable c) {
    return c == null ? null : new AutoCloseable() {

      public String toString() {
        return "c.close();\r\n    _registerIO(c, null, false);";
      }

      public void close() throws Exception {
        c.close();
        _registerIO(c, null, false);
      }
    };
  }

  static public <A> A _registerIOWrap(A wrapper, Object wrapped) {
    return wrapper;
  }

  static public FileInputStream newFileInputStream(File path) throws IOException {
    return newFileInputStream(path.getPath());
  }

  static public FileInputStream newFileInputStream(String path) throws IOException {
    FileInputStream f = new FileInputStream(path);
    _registerIO(f, path, true);
    return f;
  }

  static public String getStackTrace2(Throwable e) {
    return hideCredentials(getStackTrace(unwrapTrivialExceptionWraps(e)) + replacePrefix("java.lang.RuntimeException: ", "FAIL: ", hideCredentials(str(innerException2(e)))) + "\n");
  }

  static public <A, B> AutoCloseable tempRemove(Map<A, B> map, A key) {
    if (map == null || !map.containsKey(key))
      return null;
    B b = map.get(key);
    map.remove(key);
    return new AutoCloseable() {

      public String toString() {
        return "map.put(key, b);";
      }

      public void close() throws Exception {
        map.put(key, b);
      }
    };
  }

  static public Class primitiveToBoxedType(Class type) {
    if (type == boolean.class)
      return Boolean.class;
    if (type == int.class)
      return Integer.class;
    if (type == long.class)
      return Long.class;
    if (type == float.class)
      return Float.class;
    if (type == short.class)
      return Short.class;
    if (type == char.class)
      return Character.class;
    if (type == byte.class)
      return Byte.class;
    if (type == double.class)
      return Double.class;
    return null;
  }

  static public void dynamicObject_setRawFieldValue(DynamicObject o, Object key, Object value) {
    if (o == null)
      return;
    synchronized (o) {
      o.fieldValues = syncMapPut2_createLinkedHashMap((LinkedHashMap) o.fieldValues, key, value);
    }
  }

  static public File standardLogFile() {
    return getProgramFile("log");
  }

  static public void logQuoted(String logFile, String line) {
    logQuoted(getProgramFile(logFile), line);
  }

  static public void logQuoted(File logFile, String line) {
    appendToFile(logFile, quote(line) + "\n");
  }

  static public <A> A heldInstance(Class<A> c) {
    List<Object> l = holdInstance_l.get();
    for (int i = l(l) - 1; i >= 0; i--) {
      Object o = l.get(i);
      if (isInstanceOf(o, c))
        return (A) o;
    }
    throw fail("No instance of " + className(c) + " held");
  }

  static public IF0<Integer> preferredScreen;

  static public int preferredScreen() {
    return preferredScreen != null ? preferredScreen.get() : preferredScreen_base();
  }

  final static public int preferredScreen_fallback(IF0<Integer> _f) {
    return _f != null ? _f.get() : preferredScreen_base();
  }

  static public int preferredScreen_base() {
    return 0;
  }

  static public List vmBus_queryAll(String msg, Object... args) {
    Object arg = vmBus_wrapArgs(args);
    List out = new ArrayList();
    for (Object o : unnullForIteration(vm_busListeners_live())) addIfNotNull(out, pcallF(o, msg, arg));
    for (Object o : unnullForIteration(vm_busListenersByMessage_live().get(msg))) addIfNotNull(out, pcallF(o, msg, arg));
    return out;
  }

  static public boolean isLetterOrDigit(char c) {
    return Character.isLetterOrDigit(c);
  }

  static public <A> List<A> dropFirstThreeAndLastThree(List<A> l) {
    return dropFirstAndLast(3, l);
  }

  static public JInternalFrame getInternalFrame(final Object _o) {
    return _o == null ? null : swing(new F0<JInternalFrame>() {

      public JInternalFrame get() {
        try {
          Object o = _o;
          if (o instanceof ButtonGroup)
            o = first(buttonsInGroup((ButtonGroup) o));
          if (!(o instanceof Component))
            return null;
          Component c = (Component) o;
          while (c != null) {
            if (c instanceof JInternalFrame)
              return (JInternalFrame) c;
            c = c.getParent();
          }
          return null;
        } catch (Exception __e) {
          throw rethrow(__e);
        }
      }

      public String toString() {
        return "O o = _o;\r\n    if (o instanceof ButtonGroup) o = first(buttonsInGroup((Button...";
      }
    });
  }

  static public JButton setButtonImage(Icon img, JButton btn) {
    btn.setIcon(img);
    return btn;
  }

  static public JButton setButtonImage(Image img, JButton btn) {
    btn.setIcon(imageIcon(img));
    return btn;
  }

  static public <A extends AbstractButton> A setButtonImage(Image img, A btn) {
    btn.setIcon(imageIcon(img));
    return btn;
  }

  static public <A extends AbstractButton> A setButtonImage(A btn, Image img) {
    return setButtonImage(img, btn);
  }

  static public <A extends AbstractButton> A setButtonImage(A btn, String imageID) {
    btn.setIcon(imageIcon(imageID));
    return btn;
  }

  static public JButton setButtonImage(JButton btn, Image img) {
    return setButtonImage(img, btn);
  }

  static public JButton setButtonImage(JButton btn, Icon img) {
    return setButtonImage(img, btn);
  }

  static public BufferedImage resizeImage(BufferedImage img, int newW, int newH) {
    return resizeImage(img, newW, newH, Image.SCALE_SMOOTH);
  }

  static public BufferedImage resizeImage(BufferedImage img, int newW, int newH, int scaleType) {
    if (newW == img.getWidth() && newH == img.getHeight())
      return img;
    Image tmp = img.getScaledInstance(newW, newH, scaleType);
    BufferedImage dimg = new BufferedImage(newW, newH, BufferedImage.TYPE_INT_ARGB);
    Graphics2D g2d = dimg.createGraphics();
    g2d.drawImage(tmp, 0, 0, null);
    g2d.dispose();
    return dimg;
  }

  static public BufferedImage resizeImage(BufferedImage img, int newW) {
    int newH = iround(img.getHeight() * (double) newW / img.getWidth());
    return resizeImage(img, newW, newH);
  }

  static public BufferedImage resizeImage(int newW, BufferedImage img) {
    return resizeImage(img, newW);
  }

  static public String stackTraceToString(StackTraceElement[] st) {
    return lines(st);
  }

  static public String stackTraceToString(Throwable e) {
    return getStackTrace_noRecord(e);
  }

  static public boolean boolOptParam(ThreadLocal<Boolean> tl) {
    return isTrue(optPar(tl));
  }

  static public boolean boolOptParam(Object[] __, String name) {
    return isTrue(optParam(__, name));
  }

  static public boolean boolOptParam(String name, Object[] __) {
    return boolOptParam(__, name);
  }

  static public boolean boolOptParam(String name, Map __) {
    return isTrue(optPar(name, __));
  }

  static public <A extends JTextComponent> A jenableUndoRedo(A textcomp) {
    {
      swing(() -> {
        UndoManager undo = new UndoManager();
        vm_generalWeakSet("Undo Managers").add(undo);
        setMeta(textcomp, "UndoManager", undo);
        textcomp.getDocument().addUndoableEditListener(new UndoableEditListener() {

          public void undoableEditHappened(UndoableEditEvent evt) {
            undo.addEdit(evt.getEdit());
          }
        });
        textcomp.getActionMap().put("Undo", abstractAction("Undo", new Runnable() {

          public void run() {
            try {
              if (undo.canUndo())
                undo.undo();
            } catch (Exception __e) {
              throw rethrow(__e);
            }
          }

          public String toString() {
            return "if (undo.canUndo()) undo.undo()";
          }
        }));
        textcomp.getActionMap().put("Redo", abstractAction("Redo", new Runnable() {

          public void run() {
            try {
              if (undo.canRedo())
                undo.redo();
            } catch (Exception __e) {
              throw rethrow(__e);
            }
          }

          public String toString() {
            return "if (undo.canRedo()) undo.redo()";
          }
        }));
        textcomp.getInputMap().put(KeyStroke.getKeyStroke("control Z"), "Undo");
        textcomp.getInputMap().put(KeyStroke.getKeyStroke("control Y"), "Redo");
      });
    }
    return textcomp;
  }

  static public Lock downloadLock_lock = fairLock();

  static public Lock downloadLock() {
    return downloadLock_lock;
  }

  static public String getSnippetTitleOpt(String s) {
    try {
      return isSnippetID(s) ? getSnippetTitle(s) : s;
    } catch (Throwable __e) {
      printStackTrace(__e);
    }
    return s;
  }

  static public boolean isSubstanceLAF() {
    return substanceLookAndFeelEnabled();
  }

  static public boolean titlePopupMenu(final Component c, final Object menuMaker) {
    JComponent titleBar = getTitlePaneComponent(getPossiblyInternalFrame(c));
    if (titleBar == null) {
      print("Can't add title right click!");
      return false;
    } else {
      componentPopupMenu(titleBar, menuMaker);
      return true;
    }
  }

  static public void restart() {
    Object j = getJavaX();
    call(j, "cleanRestart", get(j, "fullArgs"));
  }

  static public void duplicateThisProgram() {
    nohupJavax(trim(programID() + " " + smartJoin((String[]) get(getJavaX(), "fullArgs"))));
  }

  static public void showConsole() {
    callOpt(get(javax(), "console"), "showConsole");
  }

  static public JCheckBoxMenuItem jCheckBoxMenuItem(String text, boolean checked, final Object r) {
    final JCheckBoxMenuItem mi = swing(() -> new JCheckBoxMenuItem(text, checked));
    addActionListener(mi, new Runnable() {

      public void run() {
        try {
          callF(r, isChecked(mi));
        } catch (Exception __e) {
          throw rethrow(__e);
        }
      }

      public String toString() {
        return "callF(r, isChecked(mi))";
      }
    });
    return mi;
  }

  static public JCheckBoxMenuItem jCheckBoxMenuItem(String text, boolean checked, IVF1<Boolean> r) {
    return jCheckBoxMenuItem(text, checked, (Object) r);
  }

  static public void toggleAlwaysOnTop(Window frame) {
    if (frame == null)
      return;
    {
      swing(() -> {
        frame.setAlwaysOnTop(!frame.isAlwaysOnTop());
      });
    }
  }

  static public Integer rectCenterX(Rect r) {
    return r == null ? null : r.x + r.w / 2;
  }

  static public Integer rectCenterY(Rect r) {
    return r == null ? null : r.y + r.h / 2;
  }

  static public <A> TreeMap<String, A> caseInsensitiveMap() {
    return new TreeMap(caseInsensitiveComparator());
  }

  static public String quickSubstring(String s, int i, int j) {
    if (i >= j)
      return "";
    return s.substring(i, j);
  }

  static public Class actualMC() {
    return or((Class) realMC(), mc());
  }

  static public Object safeUnstructure(String s) {
    return unstructure(s, true);
  }

  static public Object safeUnstructure(File f) {
    return safeUnstructureGZFile(f);
  }

  static public int parseHexChar(char c) {
    if (c >= '0' && c <= '9')
      return charDiff(c, '0');
    if (c >= 'a' && c <= 'f')
      return charDiff(c, 'a') + 10;
    if (c >= 'A' && c <= 'F')
      return charDiff(c, 'A') + 10;
    return -1;
  }

  static public Class getOuterClass(Class c) {
    return getOuterClass(c, null);
  }

  static public Class getOuterClass(Class c, Object classFinder) {
    try {
      String s = c.getName();
      int i = s.lastIndexOf('$');
      String name = substring(s, 0, i);
      return classForName(name, classFinder);
    } catch (Exception __e) {
      throw rethrow(__e);
    }
  }

  static public Class getOuterClass(Object o) {
    return getOuterClass(o, null);
  }

  static public Class getOuterClass(Object o, Object classFinder) {
    return getOuterClass(_getClass(o), classFinder);
  }

  static public HashMap<String, Field> instanceFieldsMap(Object o) {
    return (HashMap) getOpt_getFieldMap(o);
  }

  static public Map<Class, Field[]> thisDollarOneFields_cache = newDangerousWeakHashMap();

  static public Field[] thisDollarOneFields(Class c) {
    synchronized (thisDollarOneFields_cache) {
      Field[] l = thisDollarOneFields_cache.get(c);
      if (l == null)
        thisDollarOneFields_cache.put(c, l = thisDollarOneFields_uncached(c));
      return l;
    }
  }

  static public Field[] thisDollarOneFields_uncached(Class c) {
    List<Field> fields = new ArrayList();
    do {
      for (Field f : c.getDeclaredFields()) if (f.getName().startsWith("this$"))
        fields.add(makeAccessible(f));
      c = c.getSuperclass();
    } while (c != null);
    return toArray(new Field[l(fields)], fields);
  }

  static public Method fastIntern_method;

  static public String fastIntern(String s) {
    try {
      if (s == null)
        return null;
      if (fastIntern_method == null) {
        fastIntern_method = findMethodNamed(javax(), "internPerProgram");
        if (fastIntern_method == null)
          upgradeJavaXAndRestart();
      }
      return (String) fastIntern_method.invoke(null, s);
    } catch (Exception __e) {
      throw rethrow(__e);
    }
  }

  static public Map<Class, HashMap<String, Method>> callOpt_noArgs_cache = newDangerousWeakHashMap();

  static public Object callOpt_noArgs(Object o, String method) {
    try {
      if (o == null)
        return null;
      if (o instanceof Class)
        return callOpt(o, method);
      Class c = o.getClass();
      HashMap<String, Method> map;
      synchronized (callOpt_noArgs_cache) {
        map = callOpt_noArgs_cache.get(c);
        if (map == null)
          map = callOpt_noArgs_makeCache(c);
      }
      Method m = map.get(method);
      return m != null ? m.invoke(o) : null;
    } catch (Exception __e) {
      throw rethrow(__e);
    }
  }

  static public HashMap<String, Method> callOpt_noArgs_makeCache(Class c) {
    HashMap<String, Method> map = new HashMap();
    Class _c = c;
    do {
      for (Method m : c.getDeclaredMethods()) if (m.getParameterTypes().length == 0 && !reflection_isForbiddenMethod(m)) {
        makeAccessible(m);
        String name = m.getName();
        if (!map.containsKey(name))
          map.put(name, m);
      }
      _c = _c.getSuperclass();
    } while (_c != null);
    callOpt_noArgs_cache.put(c, map);
    return map;
  }

  static public String[] match2(List<String> pat, List<String> tok) {
    int i = pat.indexOf("...");
    if (i < 0)
      return match2_match(pat, tok);
    pat = new ArrayList<String>(pat);
    pat.set(i, "*");
    while (pat.size() < tok.size()) {
      pat.add(i, "*");
      pat.add(i + 1, "");
    }
    return match2_match(pat, tok);
  }

  static public String[] match2_match(List<String> pat, List<String> tok) {
    List<String> result = new ArrayList<String>();
    if (pat.size() != tok.size()) {
      return null;
    }
    for (int i = 1; i < pat.size(); i += 2) {
      String p = pat.get(i), t = tok.get(i);
      if (eq(p, "*"))
        result.add(t);
      else if (!equalsIgnoreCase(unquote(p), unquote(t)))
        return null;
    }
    return result.toArray(new String[result.size()]);
  }

  static public <A> A liftLast(List<A> l) {
    if (empty(l))
      return null;
    int i = l(l) - 1;
    A a = l.get(i);
    l.remove(i);
    return a;
  }

  static public <A> List<A> liftLast(int n, List<A> l) {
    int i = l(l) - n;
    List<A> part = cloneSubList(l, i);
    removeSubList(l, i);
    return part;
  }

  static public <A, B> Map<A, B> syncMRUCache(int size) {
    return synchroMap(new MRUCache(size));
  }

  static public RuntimeException wrapPatternSyntaxException(PatternSyntaxException e) {
    if (e == null)
      return null;
    String pat = e.getPattern();
    int i = e.getIndex();
    return new RuntimeException("Regular expression error between " + multiLineQuoteWithSpaces(substring(pat, 0, i)) + " and " + multiLineQuoteWithSpaces(substring(pat, i)) + " - " + e.getMessage());
  }

  static public Map<String, java.util.regex.Pattern> compileRegexp_cache = syncMRUCache(10);

  static public java.util.regex.Pattern compileRegexp(String pat) {
    java.util.regex.Pattern p = compileRegexp_cache.get(pat);
    if (p == null) {
      compileRegexp_cache.put(pat, p = java.util.regex.Pattern.compile(pat));
    }
    return p;
  }

  static public boolean isImageServerSnippet(long id) {
    return id >= 1100000 && id < 1200000;
  }

  static public File loadImageAsFile(String snippetIDOrURL) {
    try {
      if (isURL(snippetIDOrURL))
        throw fail("not implemented");
      if (!isSnippetID(snippetIDOrURL))
        throw fail("Not a URL or snippet ID: " + snippetIDOrURL);
      String snippetID = "" + parseSnippetID(snippetIDOrURL);
      File file = imageSnippetCacheFile(snippetID);
      if (fileSize(file) > 0)
        return file;
      String imageURL = snippetImageURL_noHttps(snippetID);
      System.err.println("Loading image: " + imageURL);
      byte[] data = loadBinaryPage(imageURL);
      saveBinaryFile(file, data);
      return file;
    } catch (Exception __e) {
      throw rethrow(__e);
    }
  }

  static public File DiskSnippetCache_file(long snippetID) {
    return new File(getGlobalCache(), "data_" + snippetID + ".jar");
  }

  public static File DiskSnippetCache_getLibrary(long snippetID) throws IOException {
    File file = DiskSnippetCache_file(snippetID);
    return file.exists() ? file : null;
  }

  public static File DiskSnippetCache_getLibrary(String snippetID) {
    try {
      return DiskSnippetCache_getLibrary(psI(snippetID));
    } catch (Exception __e) {
      throw rethrow(__e);
    }
  }

  public static void DiskSnippetCache_putLibrary(long snippetID, byte[] data) throws IOException {
    saveBinaryFile(DiskSnippetCache_file(snippetID), data);
  }

  static public byte[] loadDataSnippetImpl(String snippetID) throws IOException {
    byte[] data;
    try {
      URL url = new URL(dataSnippetLink(snippetID));
      print("Loading library: " + hideCredentials(url));
      try {
        data = loadBinaryPage(url.openConnection());
      } catch (RuntimeException e) {
        data = null;
      }
      if (data == null || data.length == 0) {
        url = new URL(tb_mainServer() + "/blobs/" + parseSnippetID(snippetID));
        print("Loading library: " + hideCredentials(url));
        data = loadBinaryPage(url.openConnection());
      }
      print("Bytes loaded: " + data.length);
    } catch (FileNotFoundException e) {
      throw new IOException("Binary snippet #" + snippetID + " not found or not public");
    }
    return data;
  }

  static public long fileSize(String path) {
    return getFileSize(path);
  }

  static public long fileSize(File f) {
    return getFileSize(f);
  }

  static public File loadDataSnippetToFile(String snippetID) {
    try {
      IResourceLoader rl = vm_getResourceLoader();
      if (rl != null)
        return rl.loadLibrary(snippetID);
      return loadDataSnippetToFile_noResourceLoader(snippetID);
    } catch (Exception __e) {
      throw rethrow(__e);
    }
  }

  static public File loadDataSnippetToFile_noResourceLoader(String snippetID) {
    try {
      snippetID = fsI(snippetID);
      File f = DiskSnippetCache_file(parseSnippetID(snippetID));
      List<URL> urlsTried = new ArrayList();
      List<Throwable> errors = new ArrayList();
      try {
        URL url = addAndReturn(urlsTried, new URL(dataSnippetLink(snippetID)));
        print("Loading library: " + hideCredentials(url));
        try {
          loadBinaryPageToFile(openConnection(url), f);
          if (fileSize(f) == 0)
            throw fail();
        } catch (Throwable e) {
          errors.add(e);
          url = addAndReturn(urlsTried, new URL(tb_mainServer() + "/blobs/" + psI(snippetID)));
          print(e);
          print("Trying other server: " + hideCredentials(url));
          loadBinaryPageToFile(openConnection(url), f);
          print("Got bytes: " + fileSize(f));
        }
        if (fileSize(f) == 0)
          throw fail();
        System.err.println("Bytes loaded: " + fileSize(f));
      } catch (Throwable e) {
        errors.add(e);
        throw fail("Binary snippet " + snippetID + " not found or not public. URLs tried: " + allToString(urlsTried) + ", errors: " + allToString(errors));
      }
      return f;
    } catch (Exception __e) {
      throw rethrow(__e);
    }
  }

  static public byte[] isGIF_magic = bytesFromHex("47494638");

  static public boolean isGIF(byte[] data) {
    return byteArrayStartsWith(data, isGIF_magic);
  }

  static public boolean isGIF(File f) {
    return isGIF(loadBeginningOfBinaryFile(f, l(isGIF_magic)));
  }

  static public <A> void setVar(IVar<A> v, A value) {
    if (v != null)
      v.set(value);
  }

  static public <A> IVF1<A> setVar(IVar<A> v) {
    return a -> {
      if (v != null)
        v.set(a);
    };
  }

  static public int findEndOfCurlyBracketPart(List<String> cnc, int i) {
    int j = i + 2, level = 1;
    while (j < cnc.size()) {
      if (eq(cnc.get(j), "{"))
        ++level;
      else if (eq(cnc.get(j), "}"))
        --level;
      if (level == 0)
        return j + 1;
      ++j;
    }
    return cnc.size();
  }

  static public String imageServerLink(String md5OrID) {
    if (possibleMD5(md5OrID))
      return "https://botcompany.de/images/md5/" + md5OrID;
    return imageServerLink(parseSnippetID(md5OrID));
  }

  static public String imageServerLink(long id) {
    return "https://botcompany.de/images/" + id;
  }

  static public Rectangle getBounds(final Component c) {
    return c == null ? null : swing(new F0<Rectangle>() {

      public Rectangle get() {
        try {
          return c.getBounds();
        } catch (Exception __e) {
          throw rethrow(__e);
        }
      }

      public String toString() {
        return "return c.getBounds();";
      }
    });
  }

  static public Rect pointsRect(int x1, int y1, int x2, int y2) {
    return new Rect(x1, y1, x2 - x1, y2 - y1);
  }

  static public <A> IterableIterator<A> iteratorFromFunction_f0(final F0<A> f) {
    class IFF2 extends IterableIterator<A> {

      public A a;

      public boolean done = false;

      public boolean hasNext() {
        getNext();
        return !done;
      }

      public A next() {
        getNext();
        if (done)
          throw fail();
        A _a = a;
        a = null;
        return _a;
      }

      public void getNext() {
        if (done || a != null)
          return;
        a = f.get();
        done = a == null;
      }
    }
    ;
    return new IFF2();
  }

  static public <A> IterableIterator<A> iteratorFromFunction_if0(final IF0<A> f) {
    class IFF2 extends IterableIterator<A> {

      public A a;

      public boolean done = false;

      public boolean hasNext() {
        getNext();
        return !done;
      }

      public A next() {
        getNext();
        if (done)
          throw fail();
        A _a = a;
        a = null;
        return _a;
      }

      public void getNext() {
        if (done || a != null)
          return;
        a = f.get();
        done = a == null;
      }
    }
    ;
    return new IFF2();
  }

  static public TreeSet<String> caseInsensitiveSet_treeSet() {
    return new TreeSet(caseInsensitiveComparator());
  }

  static public TreeSet<String> caseInsensitiveSet_treeSet(Collection<String> c) {
    return toCaseInsensitiveSet_treeSet(c);
  }

  static public Font loadFont(String snippetID) {
    try {
      return loadFont(snippetID, 12f);
    } catch (Exception __e) {
      throw rethrow(__e);
    }
  }

  static public Font loadFont(InputStream in) {
    try {
      return Font.createFont(Font.TRUETYPE_FONT, in);
    } catch (Exception __e) {
      throw rethrow(__e);
    }
  }

  static public Font loadFont(String snippetID, float fontSize) {
    return loadFont(loadLibrary(snippetID), fontSize);
  }

  static public Font loadFont(File f, float fontSize) {
    try {
      return Font.createFont(Font.TRUETYPE_FONT, f).deriveFont(fontSize);
    } catch (Exception __e) {
      throw rethrow(__e);
    }
  }

  static public Font loadFont(InputStream in, float fontSize) {
    try {
      return Font.createFont(Font.TRUETYPE_FONT, in).deriveFont(fontSize);
    } catch (Exception __e) {
      throw rethrow(__e);
    }
  }

  static public void setMenuBar(final JMenuBar mb, final RootPaneContainer f) {
    {
      swing(() -> {
        call(f, "setJMenuBar", mb);
        revalidate((Component) f);
      });
    }
  }

  static public void setMenuBar(RootPaneContainer f, JMenuBar mb) {
    setMenuBar(mb, f);
  }

  static public <A> ArrayList<A> cloneListSynchronizingOn(Collection<A> l, Object mutex) {
    if (l == null)
      return new ArrayList();
    synchronized (mutex) {
      return new ArrayList<A>(l);
    }
  }

  static public String xltrim(String s) {
    int i = 0, n = l(s);
    while (i < n && contains(" \t\r\n", s.charAt(i))) ++i;
    return substr(s, i);
  }

  static public String takeCharsWhile(String s, Object pred) {
    int i = 0;
    while (i < l(s) && isTrue(callF(pred, s.charAt(i)))) ++i;
    return substring(s, 0, i);
  }

  static public String takeCharsWhile(IF1<Character, Boolean> f, String s) {
    return takeCharsWhile(s, f);
  }

  static public String intToHex_flexLength(int i) {
    return Integer.toHexString(i);
  }

  static public String htmlencode_forParams_v2(String s) {
    if (s == null)
      return "";
    StringBuilder out = new StringBuilder(Math.max(16, s.length()));
    for (int i = 0; i < s.length(); i++) {
      char c = s.charAt(i);
      if (c > 127 || c == '"' || c == '<' || c == '>' || c == '&') {
        out.append("&#");
        out.append((int) c);
        out.append(';');
      } else
        out.append(c);
    }
    return out.toString();
  }

  static public Map<BufferedImage, Object> createGraphics_modulators = synchroIdentityHashMap();

  static public Graphics2D createGraphics(BufferedImage img) {
    Graphics2D g = img.createGraphics();
    Object mod = createGraphics_modulators.get(img);
    if (mod != null)
      callF(mod, g);
    return g;
  }

  static public void createGraphics_modulate(BufferedImage img, Object mod) {
    mapPut2(createGraphics_modulators, img, mod);
  }

  static public ThreadLocal<Boolean> imageGraphics_antiAlias = new ThreadLocal();

  static public Graphics2D imageGraphics(BufferedImage img) {
    return !isFalse(imageGraphics_antiAlias.get()) ? antiAliasGraphics(img) : createGraphics(img);
  }

  static public Throwable unwrapTrivialExceptionWraps(Throwable e) {
    if (e == null)
      return e;
    while (e.getClass() == RuntimeException.class && e.getCause() != null && eq(e.getMessage(), str(e.getCause()))) e = e.getCause();
    return e;
  }

  static public <A, B> LinkedHashMap<A, B> syncMapPut2_createLinkedHashMap(LinkedHashMap<A, B> map, A key, B value) {
    if (key != null)
      if (value != null) {
        if (map == null)
          map = new LinkedHashMap();
        synchronized (collectionMutex(map)) {
          map.put(key, value);
        }
      } else if (map != null)
        synchronized (collectionMutex(map)) {
          map.remove(key);
        }
    return map;
  }

  static public boolean isInstanceOf(Object o, Class type) {
    return type.isInstance(o);
  }

  static public <A> boolean addIfNotNull(Collection<A> l, A a) {
    return a != null && l != null & l.add(a);
  }

  static public <A> void addIfNotNull(MultiSet<A> ms, A a) {
    if (a != null && ms != null)
      ms.add(a);
  }

  static public <A> List<A> dropFirstAndLast(int n, List<A> l) {
    return cloneSubList(l, n, l(l) - n);
  }

  static public <A> List<A> dropFirstAndLast(int m, int n, List<A> l) {
    return cloneSubList(l, m, l(l) - n);
  }

  static public <A> List<A> dropFirstAndLast(List<A> l) {
    return dropFirstAndLast(1, l);
  }

  static public String dropFirstAndLast(String s) {
    return substring(s, 1, l(s) - 1);
  }

  static public Set vm_generalWeakSet(Object name) {
    synchronized (vm_generalMap()) {
      Set set = (Set) (vm_generalMap_get(name));
      if (set == null)
        vm_generalMap_put(name, set = newWeakHashSet());
      return set;
    }
  }

  static public String getSnippetTitle(String id) {
    if (id == null)
      return null;
    if (!isSnippetID(id))
      return "?";
    IResourceLoader rl = vm_getResourceLoader();
    if (rl != null)
      return rl.getSnippetTitle(id);
    return getSnippetTitle_noResourceLoader(id);
  }

  static public String getSnippetTitle_noResourceLoader(String id) {
    try {
      if (isLocalSnippetID(id))
        return localSnippetTitle(id);
      long parsedID = parseSnippetID(id);
      String url;
      if (isImageServerSnippet(parsedID))
        url = imageServerURL() + "title/" + parsedID + muricaCredentialsQuery();
      else if (isGeneralFileServerSnippet(parsedID))
        url = "http://butter.botcompany.de:8080/files/name/" + parsedID;
      else
        url = tb_mainServer() + "/tb-int/getfield.php?id=" + parsedID + "&field=title" + standardCredentials_noCookies();
      String title = trim(loadPageSilently(url));
      if (title != null)
        try {
          saveTextFileIfChanged(snippetTitle_cacheFile(id), title);
        } catch (Throwable __e) {
          print(exceptionToStringShort(__e));
        }
      return or(title, "?");
    } catch (Exception __e) {
      throw rethrow(__e);
    }
  }

  static public String getSnippetTitle(long id) {
    return getSnippetTitle(fsI(id));
  }

  static public boolean substanceLookAndFeelEnabled() {
    return startsWith(getLookAndFeel(), "org.pushingpixels.");
  }

  static public JComponent getTitlePaneComponent(RootPaneContainer window) {
    if (window instanceof JInternalFrame)
      return getInternalFrameTitlePaneComponent((JInternalFrame) window);
    if (!substanceLookAndFeelEnabled() || window == null)
      return null;
    JRootPane rootPane = window.getRootPane();
    if (rootPane != null) {
      Object ui = rootPane.getUI();
      return (JComponent) call(ui, "getTitlePane");
    }
    return null;
  }

  static public void nohupJavax(final String javaxargs) {
    {
      startThread(new Runnable() {

        public void run() {
          try {
            call(hotwireOnce("#1008562"), "nohupJavax", javaxargs);
          } catch (Exception __e) {
            throw rethrow(__e);
          }
        }

        public String toString() {
          return "call(hotwireOnce(\"#1008562\"), \"nohupJavax\", javaxargs);";
        }
      });
    }
  }

  static public void nohupJavax(final String javaxargs, final String vmArgs) {
    {
      startThread(new Runnable() {

        public void run() {
          try {
            call(hotwireOnce("#1008562"), "nohupJavax", javaxargs, vmArgs);
          } catch (Exception __e) {
            throw rethrow(__e);
          }
        }

        public String toString() {
          return "call(hotwireOnce(\"#1008562\"), \"nohupJavax\", javaxargs, vmArgs);";
        }
      });
    }
  }

  static public String smartJoin(String[] args) {
    if (empty(args))
      return "";
    if (args.length == 1)
      return args[0];
    String[] a = new String[args.length];
    for (int i = 0; i < a.length; i++) a[i] = !isJavaIdentifier(args[i]) && !isQuoted(args[i]) ? quote(args[i]) : args[i];
    return join(" ", a);
  }

  static public String smartJoin(List<String> args) {
    return smartJoin(toStringArray(args));
  }

  static public boolean isChecked(JCheckBox checkBox) {
    return checkBox != null && (boolean) swing(new F0<Boolean>() {

      public Boolean get() {
        try {
          return checkBox.isSelected();
        } catch (Exception __e) {
          throw rethrow(__e);
        }
      }

      public String toString() {
        return "return checkBox.isSelected();";
      }
    });
  }

  static public boolean isChecked(JCheckBoxMenuItem mi) {
    return mi != null && (boolean) swing(new F0<Boolean>() {

      public Boolean get() {
        try {
          return mi.isSelected();
        } catch (Exception __e) {
          throw rethrow(__e);
        }
      }

      public String toString() {
        return "return mi.isSelected();";
      }
    });
  }

  static public boolean isChecked(JRadioButton rb) {
    return rb != null && (boolean) swing(() -> rb.isSelected());
  }

  static public Object realMC() {
    return getThreadLocal(realMC_tl());
  }

  static public Object safeUnstructureGZFile(File f) {
    try {
      if (!fileExists(f))
        return null;
      BufferedReader reader = utf8BufferedReader(gzInputStream(f));
      return unstructure_tok(javaTokC_noMLS_onReader(reader), true, null);
    } catch (Exception __e) {
      throw rethrow(__e);
    }
  }

  static public int charDiff(char a, char b) {
    return (int) a - (int) b;
  }

  static public int charDiff(String a, char b) {
    return charDiff(stringToChar(a), b);
  }

  static public void upgradeJavaXAndRestart() {
    run("#1001639");
    restart();
    sleep();
  }

  static public boolean equalsIgnoreCase(String a, String b) {
    return eqic(a, b);
  }

  static public boolean equalsIgnoreCase(char a, char b) {
    return eqic(a, b);
  }

  static public String multiLineQuoteWithSpaces(String s) {
    return multiLineQuote(" " + s + " ");
  }

  static public File imageSnippetCacheFile(String snippetID) {
    File dir = imageSnippetsCacheDir();
    if (!loadBufferedImage_useImageCache)
      return null;
    return new File(dir, parseSnippetID(snippetID) + ".png");
  }

  static public String snippetImageURL_noHttps(String snippetID) {
    return snippetImageURL_noHttps(snippetID, "png");
  }

  static public String snippetImageURL_noHttps(String snippetID, String contentType) {
    return snippetImageURL(snippetID, contentType).replace("https://www.botcompany.de:8443/", "http://www.botcompany.de:8080/").replace("https://botcompany.de/", "http://botcompany.de/");
  }

  static public ThreadLocal<Map<String, List<String>>> loadBinaryPage_responseHeaders = new ThreadLocal();

  static public ThreadLocal<Map<String, String>> loadBinaryPage_extraHeaders = new ThreadLocal();

  static public byte[] loadBinaryPage(String url) {
    try {
      print("Loading " + url);
      return loadBinaryPage(loadPage_openConnection(new URL(url)));
    } catch (Exception __e) {
      throw rethrow(__e);
    }
  }

  static public byte[] loadBinaryPage(URLConnection con) {
    try {
      Map<String, String> extraHeaders = getAndClearThreadLocal(loadBinaryPage_extraHeaders);
      setHeaders(con);
      for (String key : keys(extraHeaders)) con.setRequestProperty(key, extraHeaders.get(key));
      return loadBinaryPage_noHeaders(con);
    } catch (Exception __e) {
      throw rethrow(__e);
    }
  }

  static public byte[] loadBinaryPage_noHeaders(URLConnection con) {
    try {
      ByteArrayOutputStream buf = new ByteArrayOutputStream();
      InputStream inputStream = con.getInputStream();
      loadBinaryPage_responseHeaders.set(con.getHeaderFields());
      long len = 0;
      try {
        len = con.getContentLength();
      } catch (Throwable e) {
        printStackTrace(e);
      }
      int n = 0;
      while (true) {
        int ch = inputStream.read();
        if (ch < 0)
          break;
        buf.write(ch);
        if (++n % 100000 == 0)
          println("  " + n + (len != 0 ? "/" + len : "") + " bytes loaded.");
      }
      inputStream.close();
      return buf.toByteArray();
    } catch (Exception __e) {
      throw rethrow(__e);
    }
  }

  public static byte[] saveBinaryFile(String fileName, byte[] contents) {
    try {
      File file = new File(fileName);
      File parentFile = file.getParentFile();
      if (parentFile != null)
        parentFile.mkdirs();
      String tempFileName = fileName + "_temp";
      FileOutputStream fileOutputStream = newFileOutputStream(tempFileName);
      fileOutputStream.write(contents);
      fileOutputStream.close();
      if (file.exists() && !file.delete())
        throw new IOException("Can't delete " + fileName);
      if (!new File(tempFileName).renameTo(file))
        throw new IOException("Can't rename " + tempFileName + " to " + fileName);
      vmBus_send("wroteFile", file);
      return contents;
    } catch (Exception __e) {
      throw rethrow(__e);
    }
  }

  static public byte[] saveBinaryFile(File fileName, byte[] contents) {
    return saveBinaryFile(fileName.getPath(), contents);
  }

  static public File getGlobalCache() {
    File file = new File(javaxCachesDir(), "Binary Snippets");
    file.mkdirs();
    return file;
  }

  static public long psI(String snippetID) {
    return parseSnippetID(snippetID);
  }

  static public String dataSnippetLink(String snippetID) {
    long id = parseSnippetID(snippetID);
    if (id >= 1100000 && id < 1200000)
      return imageServerURL() + id;
    if (id >= 1200000 && id < 1300000) {
      String pw = muricaPassword();
      if (empty(pw))
        throw fail("Please set 'murica password by running #1008829");
      return "https://botcompany.de/files/" + id + "?_pass=" + pw;
    }
    return fileServerURL() + "/" + id;
  }

  static public String tb_mainServer_default = "https://code.botcompany.de:9898";

  static public Object tb_mainServer_override;

  static public String tb_mainServer() {
    if (tb_mainServer_override != null)
      return (String) callF(tb_mainServer_override);
    return trim(loadTextFile(tb_mainServer_file(), tb_mainServer_default));
  }

  static public File tb_mainServer_file() {
    return getProgramFile("#1001638", "mainserver.txt");
  }

  static public boolean tb_mainServer_isDefault() {
    return eq(tb_mainServer(), tb_mainServer_default);
  }

  static public void loadBinaryPageToFile(String url, File file) {
    try {
      print("Loading " + url);
      loadBinaryPageToFile(openConnection(new URL(url)), file);
    } catch (Exception __e) {
      throw rethrow(__e);
    }
  }

  static public void loadBinaryPageToFile(URLConnection con, File file) {
    try {
      setHeaders(con);
      loadBinaryPageToFile_noHeaders(con, file);
    } catch (Exception __e) {
      throw rethrow(__e);
    }
  }

  static public void loadBinaryPageToFile_noHeaders(URLConnection con, File file) {
    try {
      File ftemp = new File(f2s(file) + "_temp");
      FileOutputStream buf = newFileOutputStream(mkdirsFor(ftemp));
      try {
        InputStream inputStream = con.getInputStream();
        long len = 0;
        try {
          len = con.getContentLength();
        } catch (Throwable e) {
          printStackTrace(e);
        }
        String pat = "  {*}" + (len != 0 ? "/" + len : "") + " bytes loaded.";
        copyStreamWithPrints(inputStream, buf, pat);
        inputStream.close();
        buf.close();
        file.delete();
        renameFile_assertTrue(ftemp, file);
      } finally {
        if (buf != null)
          buf.close();
      }
    } catch (Exception __e) {
      throw rethrow(__e);
    }
  }

  static public URLConnection openConnection(String url) {
    try {
      return openConnection(new URL(url));
    } catch (Exception __e) {
      throw rethrow(__e);
    }
  }

  static public URLConnection openConnection(URL url) {
    try {
      ping();
      callOpt(javax(), "recordOpenURLConnection", str(url));
      return url.openConnection();
    } catch (Exception __e) {
      throw rethrow(__e);
    }
  }

  static public byte[] bytesFromHex(String s) {
    return hexToBytes(s);
  }

  static public boolean byteArrayStartsWith(byte[] a, byte[] b) {
    if (a == null || b == null)
      return false;
    if (a.length < b.length)
      return false;
    for (int i = 0; i < b.length; i++) if (a[i] != b[i])
      return false;
    return true;
  }

  static public byte[] loadBeginningOfBinaryFile(File file, int maxBytes) {
    return loadBinaryFilePart(file, 0, maxBytes);
  }

  static public boolean possibleMD5(String s) {
    return isMD5(s);
  }

  static public TreeSet<String> toCaseInsensitiveSet_treeSet(Iterable<String> c) {
    if (isCISet(c))
      return (TreeSet) c;
    TreeSet<String> set = caseInsensitiveSet_treeSet();
    addAll(set, c);
    return set;
  }

  static public TreeSet<String> toCaseInsensitiveSet_treeSet(String... x) {
    TreeSet<String> set = caseInsensitiveSet_treeSet();
    addAll(set, x);
    return set;
  }

  static public File loadLibrary(String snippetID) {
    return loadBinarySnippet(snippetID);
  }

  static public String substr(String s, int x) {
    return substring(s, x);
  }

  static public String substr(String s, int x, int y) {
    return substring(s, x, y);
  }

  static public <A, B> Map<A, B> synchroIdentityHashMap() {
    return synchroMap(new IdentityHashMap());
  }

  static public <A, B> void mapPut2(Map<A, B> map, A key, B value) {
    if (map != null && key != null)
      if (value != null)
        map.put(key, value);
      else
        map.remove(key);
  }

  static public Graphics2D antiAliasGraphics(BufferedImage img) {
    return antiAliasOn(createGraphics(img));
  }

  static public boolean isLocalSnippetID(String snippetID) {
    return isSnippetID(snippetID) && isLocalSnippetID(psI(snippetID));
  }

  static public boolean isLocalSnippetID(long snippetID) {
    return snippetID >= 1000 && snippetID <= 9999;
  }

  static public String localSnippetTitle(String snippetID) {
    if (!isLocalSnippetID(snippetID))
      return null;
    File f = localSnippetFile(snippetID);
    if (!f.exists())
      return null;
    return or2(getFileInfoField(dropExtension(f), "Title"), "Unnamed");
  }

  static public String imageServerURL() {
    return or2(trim(loadTextFile(javaxDataDir("image-server-url.txt"))), "http://botcompany.de/images/raw/");
  }

  static public String muricaCredentialsQuery() {
    return htmlQuery(muricaCredentials());
  }

  static public boolean isGeneralFileServerSnippet(long id) {
    return id >= 1400000 && id < 1500000;
  }

  static public String standardCredentials_noCookies() {
    return standardCredentials() + "&noCookies=1";
  }

  static public boolean saveTextFileIfChanged(File f, String contents) {
    return saveTextFileIfDifferent(f, contents);
  }

  static public File snippetTitle_cacheFile(String snippetID) {
    return javaxCachesDir("Snippet Titles/" + psI(snippetID));
  }

  static public String getLookAndFeel() {
    return getClassName(UIManager.getLookAndFeel());
  }

  static public JComponent getInternalFrameTitlePaneComponent(JInternalFrame f) {
    return (JComponent) childWithClassNameEndingWith(f, "InternalFrameTitlePane");
  }

  static public Class hotwireOnce(String programID) {
    return hotwireCached(programID, false);
  }

  static public BufferedReader utf8BufferedReader(InputStream in) {
    return utf8bufferedReader(in);
  }

  static public BufferedReader utf8BufferedReader(File f) {
    return utf8bufferedReader(f);
  }

  static public char stringToChar(String s) {
    if (l(s) != 1)
      throw fail("bad stringToChar: " + s);
    return firstChar(s);
  }

  static public String multiLineQuote(String s) {
    for (int i = 0; ; i++) {
      String closer = "]" + rep('=', i) + "]";
      if (!contains(s, closer))
        return "[" + rep('=', i) + "[" + s + closer;
    }
  }

  static public int loadPage_defaultTimeout = 60000;

  static public ThreadLocal<String> loadPage_charset = new ThreadLocal();

  static public boolean loadPage_allowGzip = true, loadPage_debug;

  static public boolean loadPage_anonymous = false;

  static public int loadPage_verboseness = 100000;

  static public int loadPage_retries = 1;

  static public ThreadLocal<Boolean> loadPage_silent = new ThreadLocal();

  static volatile public int loadPage_forcedTimeout;

  static public ThreadLocal<Integer> loadPage_forcedTimeout_byThread = new ThreadLocal();

  static public ThreadLocal<Map<String, List<String>>> loadPage_responseHeaders = new ThreadLocal();

  static public ThreadLocal<Map<String, String>> loadPage_extraHeaders = new ThreadLocal();

  static public ThreadLocal<Long> loadPage_sizeLimit = new ThreadLocal();

  public static String loadPageSilently(String url) {
    try {
      return loadPageSilently(new URL(loadPage_preprocess(url)));
    } catch (Exception __e) {
      throw rethrow(__e);
    }
  }

  public static String loadPageSilently(URL url) {
    try {
      if (!networkAllowanceTest(str(url)))
        throw fail("Not allowed: " + url);
      IOException e = null;
      for (int tries = 0; tries < loadPage_retries; tries++) try {
        URLConnection con = loadPage_openConnection(url);
        return loadPage(con, url);
      } catch (IOException _e) {
        e = _e;
        if (loadPage_debug)
          print(exceptionToStringShort(e));
        if (tries < loadPage_retries - 1)
          sleepSeconds(1);
      }
      throw e;
    } catch (Exception __e) {
      throw rethrow(__e);
    }
  }

  static public String loadPage_preprocess(String url) {
    if (url.startsWith("tb/"))
      url = tb_mainServer() + "/" + url;
    if (url.indexOf("://") < 0)
      url = "http://" + url;
    return url;
  }

  static public String loadPage(String url) {
    try {
      url = loadPage_preprocess(url);
      if (!isTrue(loadPage_silent.get()))
        printWithTime("Loading: " + hideCredentials(url));
      return loadPageSilently(new URL(url));
    } catch (Exception __e) {
      throw rethrow(__e);
    }
  }

  static public String loadPage(URL url) {
    return loadPage(url.toExternalForm());
  }

  static public String loadPage(URLConnection con, URL url) throws IOException {
    return loadPage(con, url, true);
  }

  static public String loadPage(URLConnection con, URL url, boolean addHeaders) throws IOException {
    Map<String, String> extraHeaders = getAndClearThreadLocal(loadPage_extraHeaders);
    Long limit = optPar(loadPage_sizeLimit);
    if (addHeaders)
      try {
        if (!loadPage_anonymous)
          setHeaders(con);
        if (loadPage_allowGzip)
          con.setRequestProperty("Accept-Encoding", "gzip");
        con.setRequestProperty("X-No-Cookies", "1");
        for (String key : keys(extraHeaders)) con.setRequestProperty(key, extraHeaders.get(key));
      } catch (Throwable e) {
      }
    vm_generalSubMap("URLConnection per thread").put(currentThread(), con);
    loadPage_responseHeaders.set(con.getHeaderFields());
    InputStream in = null;
    try {
      in = urlConnection_getInputStream(con);
      if (loadPage_debug)
        print("Put stream in map: " + currentThread());
      String contentType = con.getContentType();
      if (contentType == null) {
        throw new IOException("Page could not be read: " + hideCredentials(url));
      }
      String charset = loadPage_charset == null ? null : loadPage_charset.get();
      if (charset == null)
        charset = loadPage_guessCharset(contentType);
      if ("gzip".equals(con.getContentEncoding())) {
        if (loadPage_debug)
          print("loadPage: Using gzip.");
        in = newGZIPInputStream(in);
      }
      Reader r;
      try {
        r = new InputStreamReader(in, unquote(charset));
      } catch (UnsupportedEncodingException e) {
        print(toHex(utf8(charset)));
        throw e;
      }
      boolean silent = isTrue(loadPage_silent.get());
      StringBuilder buf = new StringBuilder();
      int n = 0;
      while (limit == null || n < limit) {
        ping();
        int ch = r.read();
        if (ch < 0)
          break;
        buf.append((char) ch);
        ++n;
        if (!silent && (n % loadPage_verboseness) == 0)
          print("  " + n + " chars read");
      }
      return buf.toString();
    } finally {
      if (loadPage_debug)
        print("loadPage done");
      vm_generalSubMap("URLConnection per thread").remove(currentThread());
      if (in != null)
        in.close();
    }
  }

  static public String loadPage_guessCharset(String contentType) {
    Matcher m = regexpMatcher("text/[a-z]+;\\s*charset=([^\\s]+)\\s*", contentType);
    String match = m.matches() ? m.group(1) : null;
    if (loadPage_debug)
      print("loadPage: contentType=" + contentType + ", match: " + match);
    return or(match, "UTF-8");
  }

  static public URLConnection loadPage_openConnection(URL url) {
    URLConnection con = openConnection(url);
    int timeout = toInt(loadPage_forcedTimeout_byThread.get());
    if (timeout == 0)
      timeout = loadPage_forcedTimeout;
    if (timeout != 0)
      setURLConnectionTimeouts(con, loadPage_forcedTimeout);
    else
      setURLConnectionDefaultTimeouts(con, loadPage_defaultTimeout);
    return con;
  }

  static public void setHeaders(URLConnection con) throws IOException {
    String computerID = getComputerID_quick();
    if (computerID != null)
      try {
        con.setRequestProperty("X-ComputerID", computerID);
        con.setRequestProperty("X-OS", System.getProperty("os.name") + " " + System.getProperty("os.version"));
      } catch (Throwable e) {
      }
  }

  static public <A> A println(A a) {
    return print(a);
  }

  static volatile public boolean muricaPassword_pretendNotAuthed = false;

  static public String muricaPassword() {
    if (muricaPassword_pretendNotAuthed)
      return null;
    return trim(loadTextFile(muricaPasswordFile()));
  }

  static public String fileServerURL() {
    return "https://botcompany.de/files";
  }

  public static File mkdirsFor(File file) {
    return mkdirsForFile(file);
  }

  static public void copyStreamWithPrints(InputStream in, OutputStream out, String pat) {
    try {
      byte[] buf = new byte[65536];
      int total = 0;
      while (true) {
        int n = in.read(buf);
        if (n <= 0)
          return;
        out.write(buf, 0, n);
        if ((total + n) / 100000 > total / 100000)
          print(pat.replace("{*}", str(roundDownTo(100000, total))));
        total += n;
      }
    } catch (Exception __e) {
      throw rethrow(__e);
    }
  }

  static public File renameFile_assertTrue(File a, File b) {
    try {
      if (a.equals(b))
        return b;
      if (!a.exists())
        throw fail("Source file not found: " + f2s(a));
      if (b.exists())
        throw fail("Target file exists: " + f2s(b));
      mkdirsForFile(b);
      if (!a.renameTo(b))
        throw fail("Can't rename " + f2s(a) + " to " + f2s(b));
      return b;
    } catch (Exception __e) {
      throw rethrow(__e);
    }
  }

  static public byte[] loadBinaryFilePart(File file, long start, long end) {
    try {
      RandomAccessFile raf = new RandomAccessFile(file, "r");
      int n = toInt(min(raf.length(), end - start));
      byte[] buffer = new byte[n];
      try {
        raf.seek(start);
        raf.readFully(buffer, 0, n);
        return buffer;
      } finally {
        raf.close();
      }
    } catch (Exception __e) {
      throw rethrow(__e);
    }
  }

  static public boolean isMD5(String s) {
    return l(s) == 32 && isLowerHexString(s);
  }

  static public boolean isCISet(Iterable<String> l) {
    return l instanceof TreeSet && ((TreeSet) l).comparator() == caseInsensitiveComparator();
  }

  static public Graphics2D antiAliasOn(Graphics2D g) {
    g.setRenderingHint(RenderingHints.KEY_TEXT_ANTIALIASING, RenderingHints.VALUE_TEXT_ANTIALIAS_ON);
    g.setRenderingHint(RenderingHints.KEY_ANTIALIASING, RenderingHints.VALUE_ANTIALIAS_ON);
    return g;
  }

  static public File localSnippetFile(long snippetID) {
    return localSnippetsDir(snippetID + ".text");
  }

  static public File localSnippetFile(String snippetID) {
    return localSnippetFile(parseSnippetID(snippetID));
  }

  static public String getFileInfoField(File f, String field) {
    return getOneLineFileInfoField(f, field);
  }

  static public File dropExtension(File f) {
    return f == null ? null : fileInSameDir(f, dropExtension(f.getName()));
  }

  static public String dropExtension(String s) {
    return takeFirst(s, smartLastIndexOf(s, '.'));
  }

  static public String htmlQuery(Map params) {
    return empty(params) ? "" : "?" + makePostData(params);
  }

  static public String htmlQuery(Object... data) {
    return empty(data) ? "" : "?" + makePostData(data);
  }

  static public Object[] muricaCredentials() {
    String pass = muricaPassword();
    return nempty(pass) ? new Object[] { "_pass", pass } : new Object[0];
  }

  static public String standardCredentials() {
    String user = standardCredentialsUser();
    String pass = standardCredentialsPass();
    if (nempty(user) && nempty(pass))
      return "&_user=" + urlencode(user) + "&_pass=" + urlencode(pass);
    return "";
  }

  static public boolean saveTextFileIfDifferent(File f, String contents) {
    if (eq(loadTextFile(f), contents))
      return false;
    {
      saveTextFile(f, contents);
      return true;
    }
  }

  static public Component childWithClassNameEndingWith(Component c, String suffix) {
    if (endsWith(className(c), suffix))
      return c;
    Component x;
    for (Component comp : getComponents(c)) if ((x = childWithClassNameEndingWith(comp, suffix)) != null)
      return x;
    return null;
  }

  static public TreeMap<String, Class> hotwireCached_cache = new TreeMap();

  static public Lock hotwireCached_lock = lock();

  static public Class hotwireCached(String programID) {
    return hotwireCached(programID, true);
  }

  static public Class hotwireCached(String programID, boolean runMain) {
    return hotwireCached(programID, runMain, false);
  }

  static public Class hotwireCached(String programID, boolean runMain, boolean dependent) {
    Lock __0 = hotwireCached_lock;
    lock(__0);
    try {
      programID = formatSnippetID(programID);
      Class c = hotwireCached_cache.get(programID);
      if (c == null) {
        c = hotwire(programID);
        if (dependent)
          makeDependent(c);
        if (runMain)
          callMain(c);
        hotwireCached_cache.put(programID, c);
      }
      return c;
    } finally {
      unlock(__0);
    }
  }

  static public char firstChar(String s) {
    return s.charAt(0);
  }

  static public boolean networkAllowanceTest(String url) {
    return isAllowed("networkAllowanceTest", url);
  }

  static public <A> A printWithTime(A a) {
    return printWithTime("", a);
  }

  static public <A> A printWithTime(String s, A a) {
    print(hmsWithColons() + ": " + s, a);
    return a;
  }

  static public InputStream urlConnection_getInputStream(URLConnection con) throws IOException {
    return con.getInputStream();
  }

  static public String toHex(byte[] bytes) {
    return bytesToHex(bytes);
  }

  static public String toHex(byte[] bytes, int ofs, int len) {
    return bytesToHex(bytes, ofs, len);
  }

  static public byte[] utf8(String s) {
    return toUtf8(s);
  }

  static public URLConnection setURLConnectionTimeouts(URLConnection con, long timeout) {
    con.setConnectTimeout(toInt(timeout));
    con.setReadTimeout(toInt(timeout));
    if (con.getConnectTimeout() != timeout || con.getReadTimeout() != timeout)
      print("Warning: Timeouts not set by JDK.");
    return con;
  }

  static public URLConnection setURLConnectionDefaultTimeouts(URLConnection con, long timeout) {
    if (con.getConnectTimeout() == 0) {
      con.setConnectTimeout(toInt(timeout));
      if (con.getConnectTimeout() != timeout)
        print("Warning: URL connect timeout not set by JDK.");
    }
    if (con.getReadTimeout() == 0) {
      con.setReadTimeout(toInt(timeout));
      if (con.getReadTimeout() != timeout)
        print("Warning: URL read timeout not set by JDK.");
    }
    return con;
  }

  static public String getComputerID_quick() {
    return computerID();
  }

  static public File muricaPasswordFile() {
    return new File(javaxSecretDir(), "murica/muricaPasswordFile");
  }

  static public int roundDownTo(int n, int x) {
    return x / n * n;
  }

  static public long roundDownTo(long n, long x) {
    return x / n * n;
  }

  static public boolean isLowerHexString(String s) {
    for (int i = 0; i < l(s); i++) {
      char c = s.charAt(i);
      if (c >= '0' && c <= '9' || c >= 'a' && c <= 'f') {
      } else
        return false;
    }
    return true;
  }

  static public File localSnippetsDir() {
    return javaxDataDir("Personal Programs");
  }

  static public File localSnippetsDir(String sub) {
    return newFile(localSnippetsDir(), sub);
  }

  static public String getOneLineFileInfoField(File f, String field) {
    File infoFile = associatedInfosFile(f);
    List<String> lines = lines(loadTextFile(infoFile));
    return firstStartingWithIC_drop(lines, field + ": ");
  }

  static public File fileInSameDir(File f, String newName) {
    return newFile(parentFile(f), newName);
  }

  static public int smartLastIndexOf(String s, char c) {
    if (s == null)
      return 0;
    int i = s.lastIndexOf(c);
    return i >= 0 ? i : l(s);
  }

  static public <A> int smartLastIndexOf(List<A> l, A sub) {
    int i = lastIndexOf(l, sub);
    return i < 0 ? l(l) : i;
  }

  static public String makePostData(Map map) {
    StringBuilder buf = new StringBuilder();
    for (Map.Entry<Object, Object> e : castMapToMapO(map).entrySet()) {
      String key = (String) (e.getKey());
      Object val = e.getValue();
      if (val != null) {
        String value = str(val);
        if (nempty(buf))
          buf.append("&");
        buf.append(urlencode(key)).append("=").append(urlencode((value)));
      }
    }
    return str(buf);
  }

  static public String makePostData(Object... params) {
    StringBuilder buf = new StringBuilder();
    int n = l(params);
    for (int i = 0; i + 1 < n; i += 2) {
      String key = (String) (params[i]);
      Object val = params[i + 1];
      if (val != null) {
        String value = str(val);
        if (nempty(buf))
          buf.append("&");
        buf.append(urlencode(key)).append("=").append(urlencode((value)));
      }
    }
    return str(buf);
  }

  static public String standardCredentialsUser() {
    return trim(loadTextFile(oneOfTheFiles(javaxSecretDir("tinybrain-username"), userDir(".tinybrain/username"))));
  }

  static public String standardCredentialsPass() {
    return trim(loadTextFile(oneOfTheFiles(javaxSecretDir("tinybrain-userpass"), userDir(".tinybrain/userpass"))));
  }

  static public String urlencode(String x) {
    try {
      return URLEncoder.encode(unnull(x), "UTF-8");
    } catch (UnsupportedEncodingException e) {
      throw new RuntimeException(e);
    }
  }

  static public List<Component> getComponents(final Component c) {
    return !(c instanceof Container) ? emptyList() : asList(swing(new F0<Component[]>() {

      public Component[] get() {
        try {
          return ((Container) c).getComponents();
        } catch (Exception __e) {
          throw rethrow(__e);
        }
      }

      public String toString() {
        return "return ((Container) c).getComponents();";
      }
    }));
  }

  static public Object makeDependent_postProcess;

  static public void makeDependent(Object c) {
    if (c == null)
      return;
    assertTrue("Not a class", c instanceof Class);
    dependentClasses();
    hotwire_classes.add(new WeakReference(c));
    Object local_log = getOpt(mc(), "local_log");
    if (local_log != null)
      setOpt(c, "local_log", local_log);
    Object print_byThread = getOpt(mc(), "print_byThread");
    if (print_byThread != null)
      setOpt(c, "print_byThread", print_byThread);
    callF(makeDependent_postProcess, c);
  }

  static volatile public Object isAllowed_function;

  static volatile public boolean isAllowed_all = true;

  static public boolean isAllowed(String askingMethod, Object... args) {
    Object f = vm_generalMap_get("isAllowed_function");
    if (f != null && !isTrue(callF(f, askingMethod, args)))
      return false;
    return isAllowed_all || isTrue(callF(isAllowed_function, askingMethod, args));
  }

  static public String hmsWithColons() {
    return hmsWithColons(now());
  }

  static public String hmsWithColons(long time) {
    return new SimpleDateFormat("HH:mm:ss").format(time);
  }

  static public String _computerID;

  static public Lock computerID_lock = lock();

  public static String computerID() {
    if (_computerID == null) {
      Lock __0 = computerID_lock;
      lock(__0);
      try {
        if (_computerID != null)
          return _computerID;
        File file = computerIDFile();
        _computerID = loadTextFile(file.getPath());
        if (_computerID == null) {
          _computerID = loadTextFile(userDir(".tinybrain/computer-id"));
          if (_computerID == null)
            _computerID = makeRandomID(12, new SecureRandom());
          saveTextFile(file, _computerID);
        }
      } finally {
        unlock(__0);
      }
    }
    return _computerID;
  }

  static public File javaxSecretDir_dir;

  static public File javaxSecretDir() {
    return javaxSecretDir_dir != null ? javaxSecretDir_dir : new File(userHome(), "JavaX-Secret");
  }

  static public File javaxSecretDir(String sub) {
    return newFile(javaxSecretDir(), sub);
  }

  static public File associatedInfosFile(File f) {
    return replaceExtension(f, ".infos");
  }

  static public String firstStartingWithIC_drop(Collection<String> l, final String prefix) {
    for (String s : unnull(l)) if (swic(s, prefix))
      return substring(s, l(prefix));
    return null;
  }

  static public String firstStartingWithIC_drop(String prefix, Collection<String> l) {
    return firstStartingWithIC_drop(l, prefix);
  }

  static public File parentFile(File f) {
    return dirOfFile(f);
  }

  static public Map<Object, Object> castMapToMapO(Map map) {
    return map;
  }

  static public File oneOfTheFiles(String... paths) {
    if (paths != null)
      for (String path : paths) if (fileExists(path))
        return newFile(path);
    return null;
  }

  static public File oneOfTheFiles(File... files) {
    return oneOfTheFiles(asList(files));
  }

  static public File oneOfTheFiles(Iterable<File> files) {
    if (files != null)
      for (File f : files) if (fileExists(f))
        return f;
    return null;
  }

  static public List<Class> dependentClasses() {
    return cleanUpAndGetWeakReferencesList(hotwire_classes);
  }

  static public File computerIDFile() {
    return javaxDataDir("Basic Info/computer-id.txt");
  }

  static public String makeRandomID(int length) {
    return makeRandomID(length, defaultRandomGenerator());
  }

  static public String makeRandomID(int length, Random random) {
    char[] id = new char[length];
    for (int i = 0; i < id.length; i++) id[i] = (char) ((int) 'a' + random.nextInt(26));
    return new String(id);
  }

  static public String makeRandomID(Random r, int length) {
    return makeRandomID(length, r);
  }

  static public List<WeakReference<Class>> hotwire_classes = synchroList();

  static public Class<?> hotwireDependent(String src) {
    Class c = hotwire(src);
    makeDependent(c);
    return c;
  }

  static public File replaceExtension(File f, String extOld, String extNew) {
    return newFile(replaceExtension(f2s(f), extOld, extNew));
  }

  static public File replaceExtension(File f, String extNew) {
    return replaceExtension(f, fileExtension(f), extNew);
  }

  static public String replaceExtension(String s, String extOld, String extNew) {
    s = dropSuffixIC(addPrefixOptIfNempty(".", extOld), s);
    return s + addPrefixOptIfNempty(".", extNew);
  }

  static public String replaceExtension(String name, String extNew) {
    return replaceExtension(name, fileExtension(name), extNew);
  }

  static public <A> List<A> cleanUpAndGetWeakReferencesList(List<WeakReference<A>> l) {
    if (l == null)
      return null;
    synchronized (l) {
      List<A> out = new ArrayList();
      for (int i = 0; i < l(l); i++) {
        A a = l.get(i).get();
        if (a == null)
          l.remove(i--);
        else
          out.add(a);
      }
      return out;
    }
  }

  static public String fileExtension(File f) {
    if (f == null)
      return null;
    return fileExtension(f.getName());
  }

  static public String fileExtension(String s) {
    return substring(s, smartLastIndexOf(s, '.'));
  }

  static public String dropSuffixIC(String suffix, String s) {
    return s == null ? null : ewic(s, suffix) ? s.substring(0, l(s) - l(suffix)) : s;
  }

  static public String addPrefixOptIfNempty(String prefix, String s) {
    return addPrefixIfNotEmpty2(prefix, s);
  }

  static public String addPrefixIfNotEmpty2(String prefix, String s) {
    return empty(s) ? "" : addPrefix(prefix, s);
  }

  static public String addPrefix(String prefix, String s) {
    return s.startsWith(prefix) ? s : prefix + s;
  }

  static public class Chain<A> implements Iterable<A> {

    public A element;

    public Chain<A> next;

    public int size;

    public Chain() {
    }

    public Chain(A element) {
      this.element = element;
      size = 1;
    }

    public Chain(A element, Chain<A> next) {
      this.next = next;
      this.element = element;
      size = next != null ? next.size + 1 : 1;
    }

    public String toString() {
      return str(toList());
    }

    public ArrayList<A> toList() {
      ArrayList<A> l = emptyList(size);
      Chain<A> c = this;
      while (c != null) {
        l.add(c.element);
        c = c.next;
      }
      return l;
    }

    public Iterator<A> iterator() {
      return toList().iterator();
    }
  }

  static public class JSection extends SingleComponentPanel {

    public JSection(Component c) {
      super(c);
    }

    public String getTitle() {
      Border border = getBorder();
      if (border instanceof TitledBorder)
        return ((TitledBorder) border).getTitle();
      return null;
    }
  }

  static public class MultiSetMap<A, B> implements IMultiMap<A, B> {

    public Map<A, Set<B>> data = new HashMap<A, Set<B>>();

    public int size;

    public MultiSetMap() {
    }

    public MultiSetMap(boolean useTreeMap) {
      if (useTreeMap)
        data = new TreeMap();
    }

    public MultiSetMap(MultiSetMap<A, B> map) {
      putAll(map);
    }

    public MultiSetMap(Map<A, Set<B>> data) {
      this.data = data;
    }

    public boolean put(A key, B value) {
      synchronized (data) {
        Set<B> set = data.get(key);
        if (set == null)
          data.put(key, set = _makeEmptySet());
        if (!set.add(value))
          return false;
        {
          ++size;
          return true;
        }
      }
    }

    public boolean add(A key, B value) {
      return put(key, value);
    }

    public void addAll(A key, Collection<B> values) {
      synchronized (data) {
        putAll(key, values);
      }
    }

    public void addAllIfNotThere(A key, Collection<B> values) {
      synchronized (data) {
        for (B value : values) setPut(key, value);
      }
    }

    public void setPut(A key, B value) {
      synchronized (data) {
        if (!containsPair(key, value))
          put(key, value);
      }
    }

    final public boolean contains(A key, B value) {
      return containsPair(key, value);
    }

    public boolean containsPair(A key, B value) {
      synchronized (data) {
        return get(key).contains(value);
      }
    }

    public void putAll(A key, Collection<B> values) {
      synchronized (data) {
        for (B value : values) put(key, value);
      }
    }

    public void removeAll(A key, Collection<B> values) {
      synchronized (data) {
        for (B value : values) remove(key, value);
      }
    }

    public Set<B> get(A key) {
      synchronized (data) {
        Set<B> set = data.get(key);
        return set == null ? Collections.<B>emptySet() : set;
      }
    }

    public List<B> getAndClear(A key) {
      synchronized (data) {
        List<B> l = cloneList(data.get(key));
        remove(key);
        return l;
      }
    }

    public Set<B> getOpt(A key) {
      synchronized (data) {
        return data.get(key);
      }
    }

    public Set<B> getActual(A key) {
      synchronized (data) {
        Set<B> set = data.get(key);
        if (set == null)
          data.put(key, set = _makeEmptySet());
        return set;
      }
    }

    public void clean(A key) {
      synchronized (data) {
        Set<B> list = data.get(key);
        if (list != null && list.isEmpty())
          data.remove(key);
      }
    }

    final public Set<A> keys() {
      return keySet();
    }

    public Set<A> keySet() {
      synchronized (data) {
        return data.keySet();
      }
    }

    public void remove(A key) {
      synchronized (data) {
        size -= l(data.get(key));
        data.remove(key);
      }
    }

    public void remove(A key, B value) {
      synchronized (data) {
        Set<B> set = data.get(key);
        if (set != null) {
          if (set.remove(value)) {
            --size;
            if (set.isEmpty())
              data.remove(key);
          }
        }
      }
    }

    public void clear() {
      synchronized (data) {
        data.clear();
        size = 0;
      }
    }

    public boolean containsKey(A key) {
      synchronized (data) {
        return data.containsKey(key);
      }
    }

    public B getFirst(A key) {
      synchronized (data) {
        return first(get(key));
      }
    }

    public void addAll(MultiSetMap<A, B> map) {
      putAll(map);
    }

    public void putAll(MultiSetMap<A, B> map) {
      synchronized (data) {
        for (A key : map.keySet()) putAll(key, map.get(key));
      }
    }

    public void putAll(Map<A, B> map) {
      synchronized (data) {
        if (map != null)
          for (Map.Entry<A, B> e : map.entrySet()) put(e.getKey(), e.getValue());
      }
    }

    final public int keyCount() {
      return keysSize();
    }

    public int keysSize() {
      synchronized (data) {
        return l(data);
      }
    }

    public int size() {
      synchronized (data) {
        return size;
      }
    }

    public int getSize(A key) {
      return l(data.get(key));
    }

    public int count(A key) {
      return getSize(key);
    }

    public Set<A> reverseGet(B b) {
      synchronized (data) {
        Set<A> l = new HashSet();
        for (A key : data.keySet()) if (data.get(key).contains(b))
          l.add(key);
        return l;
      }
    }

    public A keyForValue(B b) {
      synchronized (data) {
        for (A key : data.keySet()) if (data.get(key).contains(b))
          return key;
        return null;
      }
    }

    public Map<A, Set<B>> asMap() {
      synchronized (data) {
        return cloneMap(data);
      }
    }

    public boolean isEmpty() {
      synchronized (data) {
        return data.isEmpty();
      }
    }

    public Set<B> _makeEmptySet() {
      return new HashSet();
    }

    public Collection<Set<B>> allLists() {
      synchronized (data) {
        return new HashSet(data.values());
      }
    }

    public List<B> allValues() {
      return concatLists(values(data));
    }

    public List<Pair<A, B>> allEntries() {
      synchronized (data) {
        List<Pair<A, B>> l = emptyList(size);
        for (Map.Entry<? extends A, ? extends Set<B>> __0 : _entrySet(data)) {
          A a = __0.getKey();
          Set<B> set = __0.getValue();
          for (B b : set) l.add(pair(a, b));
        }
        return l;
      }
    }

    public Object mutex() {
      return data;
    }

    public String toString() {
      return "mm" + str(data);
    }

    public Pair<A, B> firstEntry() {
      synchronized (data) {
        if (empty(data))
          return null;
        Map.Entry<A, Set<B>> entry = data.entrySet().iterator().next();
        return pair(entry.getKey(), first(entry.getValue()));
      }
    }

    public A firstKey() {
      synchronized (data) {
        return main.firstKey(data);
      }
    }

    public A lastKey() {
      synchronized (data) {
        return (A) ((NavigableMap) data).lastKey();
      }
    }

    public A higherKey(Object a) {
      synchronized (data) {
        return (A) ((NavigableMap) data).higherKey(a);
      }
    }
  }

  static public class WithToolTip<A> extends Var<A> {

    final public WithToolTip<A> setToolTip(String toolTip) {
      return toolTip(toolTip);
    }

    public WithToolTip<A> toolTip(String toolTip) {
      this.toolTip = toolTip;
      return this;
    }

    final public String getToolTip() {
      return toolTip();
    }

    public String toolTip() {
      return toolTip;
    }

    public String toolTip;

    public WithToolTip() {
    }

    public WithToolTip(A value, String toolTip) {
      super(value);
      this.toolTip = toolTip;
    }

    public String toString() {
      return formatFunctionCall("WithToolTip", toolTip, get());
    }
  }

  static public class SingleThread {

    public boolean running = false;

    public Thread thread;

    public void run(Object r) {
      go(r);
    }

    synchronized public boolean go(final Object runnable) {
      if (running)
        return false;
      running = true;
      thread = startThread("Single Thread", new Runnable() {

        public void run() {
          try {
            try {
              callF(runnable);
            } finally {
              _done();
            }
          } catch (Exception __e) {
            throw rethrow(__e);
          }
        }

        public String toString() {
          return "try {\r\n        callF(runnable);\r\n      } finally {\r\n        _done();\r\n      }";
        }
      });
      return true;
    }

    synchronized public void _done() {
      running = false;
      thread = null;
    }

    synchronized public boolean running() {
      return running;
    }

    synchronized public Thread getThread() {
      return thread;
    }
  }

  static public class CompactHashMap<K, V> extends CompactAbstractMap<K, V> {

    final static public int INITIAL_SIZE = 3;

    final static public double LOAD_FACTOR = 0.6;

    final static public Object nullObject = new Object();

    final static public Object deletedObject = new Object();

    public int elements;

    public int freecells;

    public Object[] table;

    public CompactHashMap() {
      this(INITIAL_SIZE);
    }

    public CompactHashMap(int size) {
      table = new Object[(size == 0 ? 1 : size) * 2];
      elements = 0;
      freecells = tableSize();
    }

    public CompactHashMap(Map<K, V> map) {
      this(0);
      if (map != null)
        putAll(map);
    }

    public synchronized int size() {
      return elements;
    }

    public synchronized boolean isEmpty() {
      return elements == 0;
    }

    public synchronized void clear() {
      elements = 0;
      for (int ix = 0; ix < tableSize(); ix++) {
        key(ix, null);
        value(ix, null);
      }
      freecells = tableSize();
    }

    public synchronized boolean containsKey(Object k) {
      return key(findKeyIndex(k)) != null;
    }

    public synchronized boolean containsValue(Object v) {
      if (v == null)
        v = (V) nullObject;
      for (int ix = 0; ix < tableSize(); ix++) if (value(ix) != null && value(ix).equals(v))
        return true;
      return false;
    }

    public synchronized Set<Entry<K, V>> entrySet() {
      return new EntrySet();
    }

    public synchronized V remove(Object k) {
      int index = findKeyIndex(k);
      if (key(index) != null) {
        V v = value(index);
        key(index, deletedObject);
        value(index, deletedObject);
        elements--;
        return v;
      } else
        return null;
    }

    public synchronized V put(K k, V v) {
      if (k == null)
        k = (K) nullObject;
      int hash = k.hashCode();
      int index = (hash & 0x7FFFFFFF) % tableSize();
      int offset = 1;
      int deletedix = -1;
      while (key(index) != null && !(key(index).hashCode() == hash && key(index).equals(k))) {
        if (key(index) == deletedObject)
          deletedix = index;
        index = ((index + offset) & 0x7FFFFFFF) % tableSize();
        offset = offset * 2 + 1;
        if (offset == -1)
          offset = 2;
      }
      if (key(index) == null) {
        if (deletedix != -1)
          index = deletedix;
        else
          freecells--;
        elements++;
        key(index, k);
        value(index, v);
        if (1 - (freecells / (double) tableSize()) > LOAD_FACTOR)
          rehash(tableSize() * 2 + 1);
        return null;
      } else {
        V oldv = value(index);
        value(index, v);
        return oldv;
      }
    }

    public void rehash(int newCapacity) {
      int oldCapacity = tableSize();
      Object[] newTable = new Object[newCapacity * 2];
      for (int ix = 0; ix < oldCapacity; ix++) {
        Object k = key(ix);
        if (k == null || k == deletedObject)
          continue;
        int hash = k.hashCode();
        int index = (hash & 0x7FFFFFFF) % newCapacity;
        int offset = 1;
        while (newTable[index * 2] != null) {
          index = ((index + offset) & 0x7FFFFFFF) % newCapacity;
          offset = offset * 2 + 1;
          if (offset == -1)
            offset = 2;
        }
        newTable[index * 2] = k;
        newTable[index * 2 + 1] = value(ix);
      }
      table = newTable;
      freecells = tableSize() - elements;
    }

    public synchronized V get(Object k) {
      return value(findKeyIndex(k));
    }

    public synchronized Collection<V> values() {
      return new ValueCollection();
    }

    public synchronized Set<K> keySet() {
      return new KeySet();
    }

    final public int findKeyIndex(Object k) {
      if (k == null)
        k = nullObject;
      int hash = k.hashCode();
      int index = (hash & 0x7FFFFFFF) % tableSize();
      int offset = 1;
      while (key(index) != null && !(key(index).hashCode() == hash && key(index).equals(k))) {
        index = ((index + offset) & 0x7FFFFFFF) % tableSize();
        offset = offset * 2 + 1;
        if (offset == -1)
          offset = 2;
      }
      return index;
    }

    public class KeySet extends AbstractSet<K> {

      public int size() {
        synchronized (CompactHashMap.this) {
          return elements;
        }
      }

      public boolean contains(Object k) {
        synchronized (CompactHashMap.this) {
          return containsKey(k);
        }
      }

      public Iterator<K> iterator() {
        synchronized (CompactHashMap.this) {
          return new KeyIterator();
        }
      }
    }

    public class KeyIterator<K> implements Iterator<K> {

      public int ix;

      public KeyIterator() {
        synchronized (CompactHashMap.this) {
          for (; ix < tableSize(); ix++) if (value(ix) != null && key(ix) != deletedObject)
            break;
        }
      }

      public boolean hasNext() {
        synchronized (CompactHashMap.this) {
          return ix < tableSize();
        }
      }

      public void remove() {
        throw new UnsupportedOperationException("Collection is read-only");
      }

      public K next() {
        synchronized (CompactHashMap.this) {
          if (ix >= tableSize())
            throw new NoSuchElementException();
          K key = (K) key(ix++);
          for (; ix < tableSize(); ix++) if (key(ix) != null && key(ix) != deletedObject)
            break;
          return key;
        }
      }
    }

    public class EntrySet extends AbstractSet<Map.Entry<K, V>> {

      public int size() {
        synchronized (CompactHashMap.this) {
          return elements;
        }
      }

      public boolean contains(Object o) {
        synchronized (CompactHashMap.this) {
          if (o instanceof Map.Entry) {
            Object key = ((Map.Entry) o).getKey();
            if (!containsKey((Map.Entry) o))
              return false;
            return eq(((Map.Entry) o).getValue(), get(key));
          }
          return false;
        }
      }

      public Iterator<Map.Entry<K, V>> iterator() {
        return new EntryIterator();
      }
    }

    public class EntryIterator implements Iterator<Map.Entry<K, V>> {

      public int ix;

      public EntryIterator() {
        synchronized (CompactHashMap.this) {
          for (; ix < tableSize(); ix++) if (value(ix) != null && key(ix) != deletedObject)
            break;
        }
      }

      public boolean hasNext() {
        synchronized (CompactHashMap.this) {
          return ix < tableSize();
        }
      }

      public void remove() {
        throw new UnsupportedOperationException("Collection is read-only");
      }

      public Map.Entry<K, V> next() {
        synchronized (CompactHashMap.this) {
          if (ix >= tableSize())
            throw new NoSuchElementException();
          K key = key(ix);
          V val = value(ix);
          ++ix;
          for (; ix < tableSize(); ix++) if (key(ix) != null && key(ix) != deletedObject)
            break;
          return simpleMapEntry(key, val);
        }
      }
    }

    public class ValueCollection<V> extends AbstractCollection<V> {

      public int size() {
        synchronized (CompactHashMap.this) {
          return elements;
        }
      }

      public Iterator<V> iterator() {
        return new ValueIterator();
      }

      public boolean contains(Object v) {
        return containsValue(v);
      }
    }

    public class ValueIterator<V> implements Iterator<V> {

      public int ix;

      public ValueIterator() {
        synchronized (CompactHashMap.this) {
          for (; ix < table.length / 2; ix++) if (value(ix) != null && value(ix) != deletedObject)
            break;
        }
      }

      public boolean hasNext() {
        synchronized (CompactHashMap.this) {
          return ix < tableSize();
        }
      }

      public void remove() {
        throw new UnsupportedOperationException("Collection is read-only");
      }

      public V next() {
        synchronized (CompactHashMap.this) {
          if (ix >= tableSize())
            throw new NoSuchElementException();
          V value = (V) value(ix++);
          for (; ix < tableSize(); ix++) if (value(ix) != null && value(ix) != deletedObject)
            break;
          return value;
        }
      }
    }

    public K key(int i) {
      return (K) table[i * 2];
    }

    public void key(int i, Object key) {
      table[i * 2] = key;
    }

    public V value(int i) {
      return (V) table[i * 2 + 1];
    }

    public void value(int i, Object value) {
      table[i * 2 + 1] = value;
    }

    public int tableSize() {
      return table.length / 2;
    }
  }

  static public class Best_comparable<A> {

    public A best;

    public Comparable score;

    public boolean verboseNewBest, replaceIfSameScore;

    transient public Object onChange;

    transient public Object stringifier;

    synchronized public boolean isNewBest(Comparable score) {
      return this.score == null || (replaceIfSameScore ? cmp(score, this.score) >= 0 : cmp(score, this.score) > 0);
    }

    synchronized public Comparable bestScore() {
      return score;
    }

    public Comparable score() {
      return bestScore();
    }

    public Comparable getScore() {
      return bestScore();
    }

    synchronized public float floatScoreOr(float defaultValue) {
      return best == null ? defaultValue : (float) score;
    }

    public boolean put(Pair<? extends A, Comparable> p) {
      return p != null && put(p.a, p.b);
    }

    public boolean put(Best<? extends A> b) {
      return b != null && put(b.get(), b.score);
    }

    public boolean put(A a, Comparable score) {
      ping();
      boolean change = false;
      if (a != null)
        synchronized (this) {
          if (isNewBest(score)) {
            best = a;
            this.score = score;
            change = true;
          }
        }
      if (change) {
        if (verboseNewBest)
          print("New best! " + this);
        pcallF(onChange);
      }
      return change;
    }

    synchronized public A get() {
      return best;
    }

    synchronized public boolean has() {
      return best != null;
    }

    synchronized public Pair<A, Comparable> pair() {
      return main.pair(best, bestScore());
    }

    synchronized public A getIfScoreAbove(Comparable x) {
      return cmp(x, score()) >= 0 ? best : null;
    }

    public String toString() {
      return !has() ? "-" : "Score " + score + ": " + callStringifier(stringifier, best);
    }

    public boolean putAndPrintIfNewBest(A a, Comparable score) {
      if (!put(a, score))
        return false;
      {
        print(this);
        return true;
      }
    }

    synchronized public void clear() {
      best = null;
      score = 0;
    }
  }

  static public class DefunctClassLoader {
  }

  static public interface ISetAndGet<A> extends ISetter<A>, IF0<A> {
  }

  static public class ToJava {

    public Object get(Object o) {
      {
        var __1 = getOpt(o);
        if (__1 != null)
          return __1;
      }
      throw fail("Can't ToJava: " + className(o));
    }

    public Object getOpt(Object o) {
      if (o == null)
        return "null";
      if (o instanceof String)
        return quote(o);
      if (o instanceof Number)
        return str(o);
      if (o instanceof IFieldsToList)
        return formatFunctionCall("new " + shortName((IFieldsToList) o), map(__82 -> get(__82), ((IFieldsToList) o)._fieldsToList()));
      if (o instanceof List)
        return functionCall_list("ll", map(__83 -> get(__83), (List) o));
      if (o instanceof Class)
        return shortClassName((Class) o) + ".class";
      if (o instanceof int[])
        return "new int[] {" + joinWithComma(toList((int[]) o)) + "}";
      return null;
    }
  }

  static public class IntVar {

    public int a;

    public synchronized void set(int v) {
      if (v != a) {
        a = v;
        notifyAll();
      }
    }

    public synchronized int get() {
      return a;
    }

    synchronized public int waitForValue(int x) {
      try {
        while (a != x) wait();
        return a;
      } catch (Exception __e) {
        throw rethrow(__e);
      }
    }

    public String toString() {
      return str(this.get());
    }
  }

  static public class DoubleRect {

    public double x, y, w, h;

    public DoubleRect() {
    }

    public DoubleRect(Rectangle r) {
      x = r.x;
      y = r.y;
      w = r.width;
      h = r.height;
    }

    public DoubleRect(double x, double y, double w, double h) {
      this.h = h;
      this.w = w;
      this.y = y;
      this.x = x;
    }

    public boolean eq(Object o) {
      if (!(o instanceof DoubleRect))
        return false;
      if (o == this)
        return true;
      DoubleRect r = (DoubleRect) o;
      return x == r.x && y == r.y && w == r.w && h == r.h;
    }

    public String toString() {
      return x + "," + y + " / " + w + "," + h;
    }

    public double x1() {
      return x;
    }

    public double y1() {
      return y;
    }

    public double x2() {
      return x + w;
    }

    public double y2() {
      return y + h;
    }

    public boolean contains(Pt p) {
      return contains(p.x, p.y);
    }

    public boolean contains(double _x, double _y) {
      return _x >= x && _y >= y && _x < x + w && _y < y + h;
    }

    public boolean empty() {
      return w <= 0 || h <= 0;
    }
  }

  static public class Complex implements IFieldsToList {

    static final public String _fieldOrder = "re im";

    public double re;

    public double im;

    public Complex() {
    }

    public Complex(double re, double im) {
      this.im = im;
      this.re = re;
    }

    public boolean equals(Object o) {
      if (!(o instanceof Complex))
        return false;
      Complex __1 = (Complex) o;
      return re == __1.re && im == __1.im;
    }

    public int hashCode() {
      int h = -1679819632;
      h = boostHashCombine(h, _hashCode(re));
      h = boostHashCombine(h, _hashCode(im));
      return h;
    }

    public Object[] _fieldsToList() {
      return new Object[] { re, im };
    }

    public double abs() {
      return sqrt(re * re + im * im);
    }

    public double re() {
      return re;
    }

    public double im() {
      return im;
    }

    final public double angle() {
      return phase();
    }

    public double phase() {
      return Math.atan2(im, re);
    }

    public double fracAngle() {
      return fracNonNeg(angle() / twoPi());
    }

    public String toString() {
      if (im != 0)
        return re == 0 ? im + "i" : re + plusPrefixUnlessMinus(str(im)) + "i";
      else
        return str(re);
    }
  }

  static public class BetterThreadLocal<A> {

    public Map<Thread, A> map = newWeakHashMap();

    public BetterThreadLocal() {
    }

    public BetterThreadLocal(A value) {
      set(value);
    }

    public boolean isSet() {
      return map.containsKey(currentThread());
    }

    public A get() {
      if (map.containsKey(currentThread()))
        return map.get(currentThread());
      A value = initialValue();
      set(value);
      return value;
    }

    public A get(Thread thread) {
      return thread == null ? null : map.get(thread);
    }

    public void set(A a) {
      map.put(currentThread(), a);
    }

    public A initialValue() {
      return null;
    }
  }

  static public class Lowest<A> {

    public A best;

    public double score;

    transient public Object onChange;

    synchronized public boolean isNewBest(double score) {
      return best == null || score < this.score;
    }

    synchronized public double bestScore() {
      return best == null ? Double.NaN : score;
    }

    public double score() {
      return bestScore();
    }

    synchronized public float floatScore() {
      return best == null ? Float.NaN : (float) score;
    }

    synchronized public float floatScoreOr(float defaultValue) {
      return best == null ? defaultValue : (float) score;
    }

    public boolean put(A a, double score) {
      boolean change = false;
      synchronized (this) {
        if (a != null && isNewBest(score)) {
          best = a;
          this.score = score;
          change = true;
        }
      }
      if (change)
        pcallF(onChange);
      return change;
    }

    synchronized public void clear() {
      best = null;
      score = 0;
    }

    synchronized public A get() {
      return best;
    }

    synchronized public boolean has() {
      return best != null;
    }

    synchronized public Pair<A, Double> pair() {
      return best == null ? null : new Pair(best, bestScore());
    }

    public String toString() {
      return "Score " + formatDouble_significant2(score, 4) + ": " + best;
    }
  }

  static public interface IResourceLoader {

    public String loadSnippet(String snippetID);

    public String getTranspiled(String snippetID);

    public int getSnippetType(String snippetID);

    public String getSnippetTitle(String snippetID);

    public File loadLibrary(String snippetID);

    default public File pathToJavaXJar() {
      return pathToJavaxJar_noResourceLoader();
    }

    default public File getSnippetJar(String snippetID, String transpiledSrc) {
      return null;
    }
  }

  static public class Either<A, B> {

    public byte which;

    public Object value;

    public Either() {
    }

    public Either(int which, Object value) {
      this.which = (byte) which;
      this.value = value;
    }

    public boolean isA() {
      return which == 1;
    }

    public boolean isB() {
      return which == 2;
    }

    public A a() {
      if (which != 1)
        _failMe();
      return (A) value;
    }

    public B b() {
      if (which != 2)
        _failMe();
      return (B) value;
    }

    public A aOpt() {
      return which != 1 ? null : (A) value;
    }

    public B bOpt() {
      return which != 2 ? null : (B) value;
    }

    public void _failMe() {
      throw fail("Either object is of wrong type: " + shortClassName(value));
    }

    public String toString() {
      return "Either" + (isA() ? "A" : "B") + "(" + value + ")";
    }
  }

  static public class InstantNeverHideToolTip extends MouseAdapter {

    public JComponent component;

    public JToolTip toolTip;

    public Popup popup;

    public int x, y;

    public String text;

    public IF0<String> calculateText;

    public InstantNeverHideToolTip(IF0<String> calculateText, JComponent component) {
      this(component);
      this.calculateText = calculateText;
    }

    public InstantNeverHideToolTip(String text, JComponent component) {
      this(component);
      this.text = text;
    }

    public InstantNeverHideToolTip(JComponent component) {
      this.component = component;
      {
        swing(() -> {
          component.addMouseListener(InstantNeverHideToolTip.this);
          toolTip = component.createToolTip();
          bindToComponent(component, null, () -> hideToolTip());
        });
      }
    }

    @Override
    public void mouseEntered(MouseEvent e) {
      x = e.getXOnScreen() + 2;
      y = e.getYOnScreen() + 2;
      showToolTip();
    }

    public void updateText() {
      swing(() -> {
        if (calculateText != null)
          setText(calculateText.get());
      });
    }

    public void showToolTip() {
      updateText();
      if (empty(text))
        return;
      toolTip.setTipText(text);
      popup = PopupFactory.getSharedInstance().getPopup(component, toolTip, x, y);
      popup.show();
    }

    public void mouseExited(MouseEvent e) {
      hideToolTip();
    }

    public boolean toolTipShowing() {
      return popup != null;
    }

    public void hideToolTip() {
      if (popup != null) {
        popup.hide();
        popup = null;
      }
    }

    public String getText() {
      return text;
    }

    public void setText(String text) {
      swing(() -> {
        if (eq(text, getText()))
          return;
        InstantNeverHideToolTip.this.text = text;
        if (toolTipShowing()) {
          hideToolTip();
          showToolTip();
        }
      });
    }
  }

  static public class proxy_InvocationHandler implements InvocationHandler {

    public Object target;

    public proxy_InvocationHandler() {
    }

    public proxy_InvocationHandler(Object target) {
      this.target = target;
    }

    public Object invoke(Object proxy, Method method, Object[] args) {
      return call(target, method.getName(), unnull(args));
    }
  }

  static public class CompactLinkedHashSet<A> extends AbstractSet<A> {

    public UnsynchronizedCompactHashSet<Entry<A>> entries = new UnsynchronizedCompactHashSet();

    public Entry<A> head, tail;

    static public class Entry<A> {

      public A value;

      public Entry<A> prev, next;

      public int hashCode() {
        return _hashCode(value);
      }

      public boolean equals(Object o) {
        return o == this || eq(value, o);
      }
    }

    public boolean add(A a) {
      if (entries.contains(a))
        return false;
      Entry<A> n = new Entry();
      n.value = a;
      n.prev = tail;
      if (tail != null)
        tail.next = n;
      tail = n;
      if (head == null)
        head = n;
      entries.add(n);
      return true;
    }

    public boolean remove(Object a) {
      return remove(entries.find(a));
    }

    public boolean remove(Entry<A> node) {
      if (node == null)
        return false;
      if (node.next != null)
        node.next.prev = node.prev;
      else
        tail = node.prev;
      if (node.prev != null)
        node.prev.next = node.next;
      else
        head = node.next;
      entries.remove(node);
      return true;
    }

    public int size() {
      return entries.size();
    }

    public IterableIterator<A> iterator() {
      return new IterableIterator<A>() {

        public Entry<A> entry = head, prev = null;

        public boolean hasNext() {
          return entry != null;
        }

        public A next() {
          A a = entry.value;
          prev = entry;
          entry = entry.next;
          return a;
        }

        public void remove() {
          if (prev == null)
            throw new IllegalStateException();
          CompactLinkedHashSet.this.remove(prev);
          prev = null;
        }
      };
    }

    public void clear() {
      entries.clear();
      head = tail = null;
    }

    public boolean contains(Object a) {
      return entries.contains(a);
    }

    public A find(Object o) {
      Entry<A> e = entries.find(o);
      return e == null ? null : e.value;
    }

    public A prevElement(A a) {
      Entry<A> e = entries.find(a);
      if (e == null || e.prev == null)
        return null;
      return e.prev.value;
    }

    public A nextElement(A a) {
      Entry<A> e = entries.find(a);
      if (e == null || e.next == null)
        return null;
      return e.next.value;
    }

    public A first() {
      return head == null ? null : head.value;
    }

    public A last() {
      return tail == null ? null : tail.value;
    }

    public boolean removeIfSame(Object o) {
      A value = find(o);
      if (value == o) {
        remove(value);
        return true;
      }
      return false;
    }
  }

  static public class ChangeTrigger implements Runnable, IFieldsToList {

    public ChangeTriggerable target;

    public ChangeTrigger() {
    }

    public ChangeTrigger(ChangeTriggerable target) {
      this.target = target;
    }

    public String toString() {
      return shortClassName_dropNumberPrefix(this) + "(" + target + ")";
    }

    public boolean equals(Object o) {
      if (!(o instanceof ChangeTrigger))
        return false;
      ChangeTrigger __1 = (ChangeTrigger) o;
      return eq(target, __1.target);
    }

    public int hashCode() {
      int h = -1239972920;
      h = boostHashCombine(h, _hashCode(target));
      return h;
    }

    public Object[] _fieldsToList() {
      return new Object[] { target };
    }

    public void run() {
      try {
        {
          if (target != null)
            target.change();
        }
      } catch (Exception __e) {
        throw rethrow(__e);
      }
    }
  }

  static public interface IResourceHolder {

    public <A extends AutoCloseable> A add(A a);

    public Collection<AutoCloseable> takeAll();
  }

  static public class TimeoutException_Inner extends RuntimeExceptionWithCustomStackTrace {

    public Thread thread;

    public double timeoutSeconds;

    public Object function;

    public TimeoutException_Inner(double timeoutSeconds, Object function, Thread thread) {
      super("Timeout after " + iceil(timeoutSeconds) + "s by " + shorten_str(function), new Throwable("Caller"), thread.getStackTrace());
      this.thread = thread;
      this.function = function;
      this.timeoutSeconds = timeoutSeconds;
    }
  }

  static public class BufferedImageWithMeta extends BufferedImage implements IMeta {

    public BufferedImageWithMeta(ColorModel cm, WritableRaster raster, boolean isRasterPremultiplied, Hashtable<?, ?> properties) {
      super(cm, raster, isRasterPremultiplied, properties);
    }

    volatile public Object meta;

    public void _setMeta(Object meta) {
      this.meta = meta;
    }

    public Object _getMeta() {
      return meta;
    }

    final public boolean scaffolding() {
      return scaffoldingEnabled();
    }

    public boolean scaffoldingEnabled() {
      return main.scaffoldingEnabled(this);
    }

    public boolean scaffoldingEnabled(Object o) {
      return main.scaffoldingEnabled(o);
    }
  }

  static public interface IRef<A> extends IF0<A> {

    public default void replaceValue(A oldValue, A newValue) {
    }
  }

  static public class MapI<A, B> extends IterableIterator<B> {

    public IF1<A, B> f;

    public Iterator<A> it;

    public MapI(IF1<A, B> f, Iterator<A> it) {
      this.it = it;
      this.f = f;
    }

    public boolean hasNext() {
      return it.hasNext();
    }

    public B next() {
      return f.get(it.next());
    }
  }

  static public class LeftAlignedLine extends JPanel {

    public LeftAlignedLine(int spacing, Component... components) {
      this(components);
      setSpacing(spacing);
    }

    public LeftAlignedLine(Component... components) {
      setLayout(LetterLayout.leftAlignedRow());
      addAll(this, components);
    }

    public void setSpacing(int spacing) {
      ((LetterLayout) getLayout()).setSpacing(spacing, spacing);
    }

    public void add(String text) {
      add(new JLabel(text));
    }
  }

  static abstract public class CloseableIterableIterator<A> extends IterableIterator<A> implements AutoCloseable {

    public void close() throws Exception {
    }
  }

  static public interface Producer<A> {

    public A next();
  }

  static public class AlphanumComparator implements Comparator<String> {

    public boolean ignoreCase = false;

    final public boolean isDigit(char ch) {
      return ((ch >= 48) && (ch <= 57));
    }

    final public String getChunk(String s, int slength, int marker) {
      StringBuilder chunk = new StringBuilder();
      char c = s.charAt(marker);
      chunk.append(c);
      marker++;
      if (isDigit(c))
        while (marker < slength) {
          c = s.charAt(marker);
          if (!isDigit(c))
            break;
          chunk.append(c);
          marker++;
        }
      else
        while (marker < slength) {
          c = s.charAt(marker);
          if (isDigit(c))
            break;
          chunk.append(c);
          marker++;
        }
      return chunk.toString();
    }

    public int compare(String s1, String s2) {
      if (s1 == null)
        return s2 == null ? 0 : -1;
      if (s2 == null)
        return 1;
      int thisMarker = 0;
      int thatMarker = 0;
      int s1Length = s1.length();
      int s2Length = s2.length();
      while (thisMarker < s1Length && thatMarker < s2Length) {
        String thisChunk = getChunk(s1, s1Length, thisMarker);
        thisMarker += thisChunk.length();
        String thatChunk = getChunk(s2, s2Length, thatMarker);
        thatMarker += thatChunk.length();
        int result = 0;
        if (isDigit(thisChunk.charAt(0)) && isDigit(thatChunk.charAt(0))) {
          int thisChunkLength = thisChunk.length();
          result = thisChunkLength - thatChunk.length();
          if (result == 0) {
            for (int i = 0; i < thisChunkLength; i++) {
              result = thisChunk.charAt(i) - thatChunk.charAt(i);
              if (result != 0) {
                return result;
              }
            }
          }
        } else {
          result = thisChunk.compareTo(thatChunk);
        }
        if (result != 0)
          return result;
      }
      return s1Length - s2Length;
    }
  }

  static public class ReverseChain<A> implements Iterable<A> {

    public A element;

    public ReverseChain<A> prev;

    public int size;

    public ReverseChain() {
    }

    public ReverseChain(ReverseChain<A> prev, A element) {
      this.element = element;
      this.prev = prev;
      if (prev == null)
        size = 1;
      else {
        prev.check();
        size = prev.size + 1;
      }
    }

    public void check() {
      if (size < 1)
        throw fail("You called the ReverseChain default constructor. Don't do that");
    }

    public String toString() {
      return str(toList());
    }

    public ArrayList<A> toList() {
      check();
      ArrayList<A> l = emptyList(size);
      for (int i = 0; i < size; i++) l.add(null);
      int i = size;
      ReverseChain<A> c = this;
      while (c != null) {
        l.set(--i, c.element);
        c = c.prev;
      }
      return l;
    }

    public Iterator<A> iterator() {
      return toList().iterator();
    }
  }

  static public class Value<A> implements IF0<A>, IFieldsToList {

    public A value;

    public Value() {
    }

    public Value(A value) {
      this.value = value;
    }

    public boolean equals(Object o) {
      if (!(o instanceof Value))
        return false;
      Value __1 = (Value) o;
      return eq(value, __1.value);
    }

    public int hashCode() {
      int h = 82420049;
      h = boostHashCombine(h, _hashCode(value));
      return h;
    }

    public Object[] _fieldsToList() {
      return new Object[] { value };
    }

    public A get() {
      return value;
    }

    public String toString() {
      return str(get());
    }
  }

  static public class NumPadFixingInputMap extends InputMap {

    public void put(KeyStroke keyStroke, Object actionMapKey) {
      super.put(keyStroke, actionMapKey);
      Integer code = rsyntaxTextArea_fixNumPad_map.get(keyStroke.getKeyCode());
      if (code != null)
        put(KeyStroke.getKeyStroke(code, keyStroke.getModifiers()), actionMapKey);
    }

    public void replaceOn(JComponent c) {
      InputMap im = c.getInputMap();
      setParent(im.getParent());
      for (KeyStroke key : im.keys()) put(key, im.get(key));
      c.setInputMap(JComponent.WHEN_FOCUSED, this);
    }
  }

  static public interface WidthAndHeight {

    default public int w() {
      return getWidth();
    }

    public int getWidth();

    default public int h() {
      return getHeight();
    }

    public int getHeight();

    public default Rect bounds() {
      return rect(0, 0, getWidth(), getHeight());
    }

    default public int area() {
      return toInt(areaAsLong());
    }

    default public long areaAsLong() {
      return longMul(w(), h());
    }
  }

  abstract static public class CompactAbstractMap<K, V> implements Map<K, V> {

    public int size() {
      return entrySet().size();
    }

    public boolean isEmpty() {
      return size() == 0;
    }

    public boolean containsValue(Object value) {
      Iterator<Entry<K, V>> i = entrySet().iterator();
      if (value == null) {
        while (i.hasNext()) {
          Entry<K, V> e = i.next();
          if (e.getValue() == null)
            return true;
        }
      } else {
        while (i.hasNext()) {
          Entry<K, V> e = i.next();
          if (value.equals(e.getValue()))
            return true;
        }
      }
      return false;
    }

    public boolean containsKey(Object key) {
      Iterator<Entry<K, V>> i = entrySet().iterator();
      if (key == null) {
        while (i.hasNext()) {
          Entry<K, V> e = i.next();
          if (e.getKey() == null)
            return true;
        }
      } else {
        while (i.hasNext()) {
          Entry<K, V> e = i.next();
          if (key.equals(e.getKey()))
            return true;
        }
      }
      return false;
    }

    public V get(Object key) {
      Iterator<Entry<K, V>> i = entrySet().iterator();
      if (key == null) {
        while (i.hasNext()) {
          Entry<K, V> e = i.next();
          if (e.getKey() == null)
            return e.getValue();
        }
      } else {
        while (i.hasNext()) {
          Entry<K, V> e = i.next();
          if (key.equals(e.getKey()))
            return e.getValue();
        }
      }
      return null;
    }

    public V put(K key, V value) {
      throw new UnsupportedOperationException();
    }

    public V remove(Object key) {
      Iterator<Entry<K, V>> i = entrySet().iterator();
      Entry<K, V> correctEntry = null;
      if (key == null) {
        while (correctEntry == null && i.hasNext()) {
          Entry<K, V> e = i.next();
          if (e.getKey() == null)
            correctEntry = e;
        }
      } else {
        while (correctEntry == null && i.hasNext()) {
          Entry<K, V> e = i.next();
          if (key.equals(e.getKey()))
            correctEntry = e;
        }
      }
      V oldValue = null;
      if (correctEntry != null) {
        oldValue = correctEntry.getValue();
        i.remove();
      }
      return oldValue;
    }

    public void putAll(Map<? extends K, ? extends V> m) {
      for (Entry<? extends K, ? extends V> e : m.entrySet()) put(e.getKey(), e.getValue());
    }

    public void clear() {
      entrySet().clear();
    }

    public Set<K> keySet() {
      return new AbstractSet<K>() {

        public Iterator<K> iterator() {
          return new Iterator<K>() {

            public Iterator<Entry<K, V>> i = entrySet().iterator();

            public boolean hasNext() {
              return i.hasNext();
            }

            public K next() {
              return i.next().getKey();
            }

            public void remove() {
              i.remove();
            }
          };
        }

        public int size() {
          return CompactAbstractMap.this.size();
        }

        public boolean isEmpty() {
          return CompactAbstractMap.this.isEmpty();
        }

        public void clear() {
          CompactAbstractMap.this.clear();
        }

        public boolean contains(Object k) {
          return CompactAbstractMap.this.containsKey(k);
        }
      };
    }

    public Collection<V> values() {
      return new AbstractCollection<V>() {

        public Iterator<V> iterator() {
          return new Iterator<V>() {

            public Iterator<Entry<K, V>> i = entrySet().iterator();

            public boolean hasNext() {
              return i.hasNext();
            }

            public V next() {
              return i.next().getValue();
            }

            public void remove() {
              i.remove();
            }
          };
        }

        public int size() {
          return CompactAbstractMap.this.size();
        }

        public boolean isEmpty() {
          return CompactAbstractMap.this.isEmpty();
        }

        public void clear() {
          CompactAbstractMap.this.clear();
        }

        public boolean contains(Object v) {
          return CompactAbstractMap.this.containsValue(v);
        }
      };
    }

    public abstract Set<Entry<K, V>> entrySet();

    public boolean equals(Object o) {
      if (o == this)
        return true;
      if (!(o instanceof Map))
        return false;
      Map<?, ?> m = (Map<?, ?>) o;
      if (m.size() != size())
        return false;
      try {
        for (Entry<K, V> e : entrySet()) {
          K key = e.getKey();
          V value = e.getValue();
          if (value == null) {
            if (!(m.get(key) == null && m.containsKey(key)))
              return false;
          } else {
            if (!value.equals(m.get(key)))
              return false;
          }
        }
      } catch (ClassCastException unused) {
        return false;
      } catch (NullPointerException unused) {
        return false;
      }
      return true;
    }

    public int hashCode() {
      int h = 0;
      for (Entry<K, V> entry : entrySet()) h += entry.hashCode();
      return h;
    }

    public String toString() {
      Iterator<Entry<K, V>> i = entrySet().iterator();
      if (!i.hasNext())
        return "{}";
      StringBuilder sb = new StringBuilder();
      sb.append('{');
      for (; ; ) {
        Entry<K, V> e = i.next();
        K key = e.getKey();
        V value = e.getValue();
        sb.append(key == this ? "(this Map)" : key);
        sb.append('=');
        sb.append(value == this ? "(this Map)" : value);
        if (!i.hasNext())
          return sb.append('}').toString();
        sb.append(',').append(' ');
      }
    }

    public Object clone() throws CloneNotSupportedException {
      CompactAbstractMap<?, ?> result = (CompactAbstractMap<?, ?>) super.clone();
      return result;
    }

    public static class SimpleEntry<K, V> implements Entry<K, V>, java.io.Serializable {

      @java.io.Serial
      static final public long serialVersionUID = -8499721149061103585L;

      @SuppressWarnings("serial")
      final public K key;

      @SuppressWarnings("serial")
      public V value;

      public SimpleEntry(K key, V value) {
        this.key = key;
        this.value = value;
      }

      public SimpleEntry(Entry<? extends K, ? extends V> entry) {
        this.key = entry.getKey();
        this.value = entry.getValue();
      }

      public K getKey() {
        return key;
      }

      public V getValue() {
        return value;
      }

      public V setValue(V value) {
        V oldValue = this.value;
        this.value = value;
        return oldValue;
      }

      public boolean equals(Object o) {
        if (!(o instanceof Map.Entry))
          return false;
        Entry<?, ?> e = (Entry<?, ?>) o;
        return eq(key, e.getKey()) && eq(value, e.getValue());
      }

      public int hashCode() {
        return (key == null ? 0 : key.hashCode()) ^ (value == null ? 0 : value.hashCode());
      }

      public String toString() {
        return key + "=" + value;
      }
    }

    public static class SimpleImmutableEntry<K, V> implements Entry<K, V>, java.io.Serializable {

      @java.io.Serial
      static final public long serialVersionUID = 7138329143949025153L;

      @SuppressWarnings("serial")
      final public K key;

      @SuppressWarnings("serial")
      final public V value;

      public SimpleImmutableEntry(K key, V value) {
        this.key = key;
        this.value = value;
      }

      public SimpleImmutableEntry(Entry<? extends K, ? extends V> entry) {
        this.key = entry.getKey();
        this.value = entry.getValue();
      }

      public K getKey() {
        return key;
      }

      public V getValue() {
        return value;
      }

      public V setValue(V value) {
        throw new UnsupportedOperationException();
      }

      public boolean equals(Object o) {
        if (!(o instanceof Map.Entry))
          return false;
        Entry<?, ?> e = (Entry<?, ?>) o;
        return eq(key, e.getKey()) && eq(value, e.getValue());
      }

      public int hashCode() {
        return (key == null ? 0 : key.hashCode()) ^ (value == null ? 0 : value.hashCode());
      }

      public String toString() {
        return key + "=" + value;
      }
    }
  }

  static public class UnsynchronizedCompactHashSet<A> extends java.util.AbstractSet<A> {

    final static public int INITIAL_SIZE = 3;

    public final static double LOAD_FACTOR = 0.75;

    final static public Object nullObject = new Object();

    final static public Object deletedObject = new Object();

    public int elements;

    public int freecells;

    public A[] objects;

    public int modCount;

    public UnsynchronizedCompactHashSet() {
      this(INITIAL_SIZE);
    }

    public UnsynchronizedCompactHashSet(int size) {
      objects = (A[]) new Object[(size == 0 ? 1 : size)];
      elements = 0;
      freecells = objects.length;
      modCount = 0;
    }

    public UnsynchronizedCompactHashSet(Collection<A> c) {
      this(c.size());
      addAll(c);
    }

    @Override
    public Iterator<A> iterator() {
      return new CompactHashIterator<A>();
    }

    @Override
    public int size() {
      return elements;
    }

    @Override
    public boolean isEmpty() {
      return elements == 0;
    }

    @Override
    public boolean contains(Object o) {
      return find(o) != null;
    }

    public A find(Object o) {
      if (o == null)
        o = nullObject;
      int hash = o.hashCode();
      int index = (hash & 0x7FFFFFFF) % objects.length;
      int offset = 1;
      while (objects[index] != null && !(objects[index].hashCode() == hash && objects[index].equals(o))) {
        index = ((index + offset) & 0x7FFFFFFF) % objects.length;
        offset = offset * 2 + 1;
        if (offset == -1)
          offset = 2;
      }
      return objects[index];
    }

    public boolean removeIfSame(Object o) {
      A value = find(o);
      if (value == o) {
        remove(value);
        return true;
      }
      return false;
    }

    @Override
    public boolean add(Object o) {
      if (o == null)
        o = nullObject;
      int hash = o.hashCode();
      int index = (hash & 0x7FFFFFFF) % objects.length;
      int offset = 1;
      int deletedix = -1;
      while (objects[index] != null && !(objects[index].hashCode() == hash && objects[index].equals(o))) {
        if (objects[index] == deletedObject)
          deletedix = index;
        index = ((index + offset) & 0x7FFFFFFF) % objects.length;
        offset = offset * 2 + 1;
        if (offset == -1)
          offset = 2;
      }
      if (objects[index] == null) {
        if (deletedix != -1)
          index = deletedix;
        else
          freecells--;
        modCount++;
        elements++;
        objects[index] = (A) o;
        if (1 - (freecells / (double) objects.length) > LOAD_FACTOR)
          rehash();
        return true;
      } else
        return false;
    }

    @Override
    public boolean remove(Object o) {
      if (o == null)
        o = nullObject;
      int hash = o.hashCode();
      int index = (hash & 0x7FFFFFFF) % objects.length;
      int offset = 1;
      while (objects[index] != null && !(objects[index].hashCode() == hash && objects[index].equals(o))) {
        index = ((index + offset) & 0x7FFFFFFF) % objects.length;
        offset = offset * 2 + 1;
        if (offset == -1)
          offset = 2;
      }
      if (objects[index] != null) {
        objects[index] = (A) deletedObject;
        modCount++;
        elements--;
        return true;
      } else
        return false;
    }

    @Override
    public void clear() {
      elements = 0;
      for (int ix = 0; ix < objects.length; ix++) objects[ix] = null;
      freecells = objects.length;
      modCount++;
    }

    @Override
    public Object[] toArray() {
      Object[] result = new Object[elements];
      Object[] objects = this.objects;
      int pos = 0;
      for (int i = 0; i < objects.length; i++) if (objects[i] != null && objects[i] != deletedObject) {
        if (objects[i] == nullObject)
          result[pos++] = null;
        else
          result[pos++] = objects[i];
      }
      return result;
    }

    @Override
    public <T> T[] toArray(T[] a) {
      int size = elements;
      if (a.length < size)
        a = (T[]) java.lang.reflect.Array.newInstance(a.getClass().getComponentType(), size);
      A[] objects = this.objects;
      int pos = 0;
      for (int i = 0; i < objects.length; i++) if (objects[i] != null && objects[i] != deletedObject) {
        if (objects[i] == nullObject)
          a[pos++] = null;
        else
          a[pos++] = (T) objects[i];
      }
      return a;
    }

    public void rehash() {
      int garbagecells = objects.length - (elements + freecells);
      if (garbagecells / (double) objects.length > 0.05)
        rehash(objects.length);
      else
        rehash(objects.length * 2 + 1);
    }

    public void rehash(int newCapacity) {
      int oldCapacity = objects.length;
      @SuppressWarnings("unchecked")
      A[] newObjects = (A[]) new Object[newCapacity];
      for (int ix = 0; ix < oldCapacity; ix++) {
        Object o = objects[ix];
        if (o == null || o == deletedObject)
          continue;
        int hash = o.hashCode();
        int index = (hash & 0x7FFFFFFF) % newCapacity;
        int offset = 1;
        while (newObjects[index] != null) {
          index = ((index + offset) & 0x7FFFFFFF) % newCapacity;
          offset = offset * 2 + 1;
          if (offset == -1)
            offset = 2;
        }
        newObjects[index] = (A) o;
      }
      objects = newObjects;
      freecells = objects.length - elements;
    }

    public class CompactHashIterator<T> implements Iterator<T> {

      public int index;

      public int lastReturned = -1;

      public int expectedModCount;

      @SuppressWarnings("empty-statement")
      public CompactHashIterator() {
        for (index = 0; index < objects.length && (objects[index] == null || objects[index] == deletedObject); index++) ;
        expectedModCount = modCount;
      }

      @Override
      public boolean hasNext() {
        return index < objects.length;
      }

      @SuppressWarnings("empty-statement")
      @Override
      public T next() {
        int length = objects.length;
        if (index >= length) {
          lastReturned = -2;
          throw new NoSuchElementException();
        }
        lastReturned = index;
        for (index += 1; index < length && (objects[index] == null || objects[index] == deletedObject); index++) ;
        if (objects[lastReturned] == nullObject)
          return null;
        else
          return (T) objects[lastReturned];
      }

      @Override
      public void remove() {
        if (modCount != expectedModCount)
          throw new ConcurrentModificationException();
        if (lastReturned == -1 || lastReturned == -2)
          throw new IllegalStateException();
        if (objects[lastReturned] != null && objects[lastReturned] != deletedObject) {
          objects[lastReturned] = (A) deletedObject;
          elements--;
          modCount++;
          expectedModCount = modCount;
        }
      }
    }

    public int capacity() {
      return objects.length;
    }

    public boolean shrinkToFactor(double factor) {
      if (factor > LOAD_FACTOR)
        throw fail("Shrink factor must be equal to or smaller than load factor: " + factor + " / " + LOAD_FACTOR);
      int newCapacity = max(INITIAL_SIZE, iround(size() / factor));
      if (newCapacity >= capacity())
        return false;
      rehash(newCapacity);
      return true;
    }
  }

  static public class RuntimeExceptionWithCustomStackTrace extends RuntimeException {

    public RuntimeExceptionWithCustomStackTrace(String msg, Throwable cause, StackTraceElement[] stackTrace) {
      super(msg, cause, false, true);
      setStackTrace(stackTrace);
    }
  }

  static public class Best<A> {

    public A best;

    public double score;

    public boolean verboseNewBest, replaceIfSameScore;

    final public Best<A> setLowerIsBetter(boolean lowerIsBetter) {
      return lowerIsBetter(lowerIsBetter);
    }

    public Best<A> lowerIsBetter(boolean lowerIsBetter) {
      this.lowerIsBetter = lowerIsBetter;
      return this;
    }

    final public boolean getLowerIsBetter() {
      return lowerIsBetter();
    }

    public boolean lowerIsBetter() {
      return lowerIsBetter;
    }

    public boolean lowerIsBetter = false;

    transient public Object onChange;

    transient public Object stringifier;

    synchronized public boolean isNewBest(double score) {
      return best == null || !isNaN(score) && (replaceIfSameScore ? compareScores(score, this.score) >= 0 : compareScores(score, this.score) > 0);
    }

    public double worstScore() {
      return lowerIsBetter ? infinity() : minusInfinity();
    }

    public int compareScores(double a, double b) {
      return lowerIsBetter ? -cmp(a, b) : cmp(a, b);
    }

    synchronized public double bestScore() {
      return best == null ? worstScore() : score;
    }

    public double score() {
      return bestScore();
    }

    public double getScore() {
      return bestScore();
    }

    synchronized public float floatScoreOr(float defaultValue) {
      return best == null ? defaultValue : (float) score;
    }

    public boolean put(Pair<? extends A, Double> p) {
      return p != null && put(p.a, p.b);
    }

    public boolean put(Best<? extends A> b) {
      return b != null && put(b.get(), b.score);
    }

    public boolean put(A a, double score) {
      ping();
      boolean change = false;
      if (a != null)
        synchronized (this) {
          if (isNewBest(score)) {
            best = a;
            this.score = score;
            change = true;
          }
        }
      if (change) {
        if (verboseNewBest)
          print("New best! " + this);
        pcallF(onChange);
      }
      return change;
    }

    synchronized public A get() {
      return best;
    }

    synchronized public boolean has() {
      return best != null;
    }

    synchronized public Pair<A, Double> pair() {
      return main.pair(best, bestScore());
    }

    synchronized public Scored<A> scored() {
      return best == null ? null : new Scored<A>(best, bestScore());
    }

    synchronized public A getIfScoreAbove(double x) {
      return compareScores(score(), x) >= 0 ? best : null;
    }

    public String toString() {
      return "Score " + formatDouble_significant2(score, 4) + ": " + callStringifier(stringifier, best);
    }

    public boolean putAndPrintIfNewBest(A a, double score) {
      if (!put(a, score))
        return false;
      {
        print(this);
        return true;
      }
    }

    synchronized public void clear() {
      best = null;
      score = 0;
    }
  }

  static public class LetterLayout implements LayoutManager {

    public String[] lines;

    public Map<String, Component> map = new TreeMap();

    public Map<Component, String> constraints = new HashMap();

    public RC[] rows;

    public RC[] cols;

    public Cell[][] cells;

    public int spacingX = 10, spacingY = 10;

    public int insetTop, insetBottom, insetLeft, insetRight;

    public int template;

    public boolean formWideLeftSide, formWideRightSide;

    static final public int STALACTITE = 1, LEFT_ALIGNED_ROW = 2, CENTERED_ROW = 3, FORM = 4, RIGHT_ALIGNED_ROW = 5;

    public boolean debug = false;

    public void setLeftBorder(int border) {
      insetLeft = border;
    }

    public void setRightBorder(int border) {
      insetRight = border;
    }

    public static JComponent withBorder(JComponent component, int border) {
      JPanel panel = new JPanel(new LetterLayout("C").setBorder(border));
      panel.add("C", component);
      return panel;
    }

    public static JPanel panel(String... lines) {
      return new JPanel(new LetterLayout(lines));
    }

    public static JPanel stalactitePanel() {
      return new JPanel(stalactite());
    }

    static public class DummyComponent extends JComponent {
    }

    static public class Cell {

      public boolean aux = false;

      public int minWidth, minHeight;

      public Component component;

      public int colspan, rowspan;

      public double weightX, weightY;
    }

    static public class RC {

      public int min;

      public double weightSum;

      public int start;

      public int minEnd;
    }

    public LetterLayout(int template) {
      this.template = template;
    }

    public LetterLayout(String... lines) {
      this.lines = lines;
    }

    public void layoutContainer(Container container) {
      prepareLayout(container);
      if (debug)
        System.out.println("Container size: " + container.getSize());
      Insets insets = getInsets(container);
      for (int r = 0; r < rows.length; r++) {
        for (int i = 0; i < cols.length; ) {
          Cell cell = cells[i][r];
          if (cell.aux)
            ++i;
          else {
            if (cell.component != null) {
              int x1 = cols[i].start;
              int y1 = rows[r].start;
              int x2 = i + cell.colspan < cols.length ? cols[i + cell.colspan].start - spacingX : container.getWidth() - insets.right;
              int y2 = r + cell.rowspan < rows.length ? rows[r + cell.rowspan].start - spacingY : container.getHeight() - insets.bottom;
              if (debug)
                System.out.println("Layouting (" + i + ", " + r + ", " + cell.component.getClass().getName() + "): " + x1 + " " + y1 + " " + x2 + " " + y2);
              cell.component.setBounds(x1, y1, x2 - x1, y2 - y1);
            }
            i += cells[i][r].colspan;
          }
        }
      }
    }

    final public void prepareLayout(Container container) {
      applyTemplate(container);
      int numRows = lines.length, numCols = lines[0].length();
      for (int i = 1; i < numRows; i++) if (lines[i].length() != numCols)
        throw new IllegalArgumentException("Lines have varying length");
      cells = new Cell[numCols][numRows];
      rows = new RC[numRows];
      cols = new RC[numCols];
      for (int r = 0; r < numRows; r++) rows[r] = new RC();
      for (int i = 0; i < numCols; i++) cols[i] = new RC();
      for (int r = 0; r < numRows; r++) for (int i = 0; i < numCols; i++) cells[i][r] = new Cell();
      for (int r = 0; r < numRows; r++) {
        String line = lines[r];
        for (int i = 0; i < numCols; ) {
          Cell cell = cells[i][r];
          if (cell.aux) {
            ++i;
            continue;
          }
          char ch = line.charAt(i);
          int iNext = i;
          do ++iNext; while (iNext < numCols && ch == line.charAt(iNext));
          int rNext = r;
          do ++rNext; while (rNext < numRows && ch == lines[rNext].charAt(i));
          cell.weightX = numCols == 1 || iNext > i + 1 ? 1.0 : 0.0;
          cell.weightY = numRows == 1 || rNext > r + 1 ? 1.0 : 0.0;
          Component c = map.get(String.valueOf(ch));
          cell.component = c;
          if (c != null) {
            cell.minWidth = c.getMinimumSize().width + spacingX;
            cell.minHeight = getMinimumHeight(c) + spacingY;
          }
          cell.colspan = iNext - i;
          cell.rowspan = rNext - r;
          if (cell.colspan == 1)
            cols[i].min = Math.max(cols[i].min, cell.minWidth);
          if (cell.rowspan == 1)
            rows[r].min = Math.max(rows[r].min, cell.minHeight);
          for (int r2 = r; r2 < rNext; r2++) for (int i2 = i; i2 < iNext; i2++) if (r2 != r || i2 != i)
            cells[i2][r2].aux = true;
          i = iNext;
        }
      }
      while (true) {
        for (int i = 0; i < numCols; i++) {
          int minStart = i == 0 ? 0 : cols[i - 1].minEnd;
          double weightStart = i == 0 ? 0.0 : cols[i - 1].weightSum;
          for (int r = 0; r < numRows; r++) {
            Cell cell = cells[i][r];
            if (!cell.aux) {
              RC rc = cols[i + cell.colspan - 1];
              rc.minEnd = Math.max(rc.minEnd, minStart + cell.minWidth);
              rc.weightSum = Math.max(rc.weightSum, weightStart + cell.weightX);
            }
          }
        }
        for (int r = 0; r < numRows; r++) {
          int minStart = r == 0 ? 0 : rows[r - 1].minEnd;
          double weightStart = r == 0 ? 0.0 : rows[r - 1].weightSum;
          for (int i = 0; i < numCols; i++) {
            Cell cell = cells[i][r];
            if (!cell.aux) {
              RC rc = rows[r + cell.rowspan - 1];
              rc.minEnd = Math.max(rc.minEnd, minStart + cell.minHeight);
              rc.weightSum = Math.max(rc.weightSum, weightStart + cell.weightY);
            }
          }
        }
        if (allWeightsZero(cols)) {
          for (int r = 0; r < numRows; r++) for (int i = 0; i < numCols; i++) cells[i][r].weightX = 1.0;
          continue;
        }
        if (allWeightsZero(rows)) {
          for (int r = 0; r < numRows; r++) for (int i = 0; i < numCols; i++) cells[i][r].weightY = 1.0;
          continue;
        }
        break;
      }
      Insets insets = getInsets(container);
      determineStarts(cols, insets.left, container.getWidth() - insets.left - insets.right + spacingX, spacingX);
      determineStarts(rows, insets.top, container.getHeight() - insets.top - insets.bottom + spacingY, spacingY);
    }

    final public boolean allWeightsZero(RC[] rcs) {
      for (int i = 0; i < rcs.length; i++) if (rcs[i].weightSum != 0.0)
        return false;
      return true;
    }

    static public int getMinimumHeight(Component c) {
      return c.getMinimumSize().height;
    }

    final public void applyTemplate(Container container) {
      if (template == STALACTITE) {
        Component[] components = container.getComponents();
        lines = new String[components.length + 2];
        map.clear();
        for (int i = 0; i < components.length; i++) {
          String s = String.valueOf(makeIndexChar(i));
          map.put(s, components[i]);
          lines[i] = s;
        }
        lines[components.length] = lines[components.length + 1] = " ";
      } else if (template == FORM) {
        Component[] components = container.getComponents();
        int numRows = components.length / 2;
        lines = new String[numRows + 2];
        map.clear();
        for (int row = 0; row < numRows; row++) {
          String lower = String.valueOf(makeIndexChar(row));
          String upper = String.valueOf(makeAlternateIndexChar(row));
          Component rightComponent = components[row * 2 + 1];
          if (rightComponent instanceof DummyComponent)
            upper = lower;
          lines[row] = (formWideLeftSide ? lower + lower : lower) + (formWideRightSide ? upper + upper : upper);
          map.put(lower, components[row * 2]);
          if (!(rightComponent instanceof DummyComponent))
            map.put(upper, rightComponent);
        }
        lines[numRows] = lines[numRows + 1] = (formWideLeftSide ? "  " : " ") + (formWideRightSide ? "  " : " ");
      } else if (template == LEFT_ALIGNED_ROW) {
        lines = new String[] { makeSingleRow(container) + RIGHT_CHAR + RIGHT_CHAR };
      } else if (template == CENTERED_ROW) {
        lines = new String[] { "" + LEFT_CHAR + LEFT_CHAR + makeSingleRow(container) + RIGHT_CHAR + RIGHT_CHAR };
      } else if (template == RIGHT_ALIGNED_ROW) {
        lines = new String[] { "" + LEFT_CHAR + LEFT_CHAR + makeSingleRow(container) };
      }
    }

    final public String makeSingleRow(Container container) {
      Component[] components = container.getComponents();
      StringBuffer buf = new StringBuffer();
      map.clear();
      for (int i = 0; i < components.length; i++) {
        var c = components[i];
        String s = constraints.get(c);
        if (isOneOfSingleChars(s, LEFT_CHAR, RIGHT_CHAR))
          continue;
        s = str(makeAlternateIndexChar(i));
        setConstraints(c, s);
        buf.append(s);
      }
      return buf.toString();
    }

    static public void determineStarts(RC[] rcs, int start, int totalSize, int spacing) {
      int minTotal = rcs[rcs.length - 1].minEnd;
      double weightSum = rcs[rcs.length - 1].weightSum;
      int spare = (int) ((totalSize - minTotal) / (weightSum == 0.0 ? 1.0 : weightSum));
      int x = start, minSum = 0;
      double prevWeightSum = 0.0;
      for (int i = 0; i < rcs.length; i++) {
        int width = rcs[i].minEnd - minSum + (int) ((rcs[i].weightSum - prevWeightSum) * spare) - spacing;
        rcs[i].start = x;
        x += width + spacing;
        prevWeightSum = rcs[i].weightSum;
        minSum = rcs[i].minEnd;
      }
    }

    public void addLayoutComponent(String s, Component component) {
      setConstraints(component, s);
    }

    public void setConstraints(Component component, String s) {
      mapPutOrRemove(map, s, component);
      mapPutOrRemove(constraints, component, s);
    }

    public void removeLayoutComponent(Component component) {
      map.values().remove(component);
      constraints.remove(component);
    }

    public Dimension minimumLayoutSize(Container container) {
      prepareLayout(container);
      Insets insets = getInsets(container);
      Dimension result = new Dimension(insets.left + cols[cols.length - 1].minEnd + insets.right - spacingX, insets.top + rows[rows.length - 1].minEnd + insets.bottom - spacingY);
      return result;
    }

    final public Insets getInsets(Container container) {
      Insets insets = container.getInsets();
      return new Insets(insets.top + insetTop, insets.left + insetLeft, insets.bottom + insetBottom, insets.right + insetRight);
    }

    public Dimension preferredLayoutSize(Container container) {
      return minimumLayoutSize(container);
    }

    public LetterLayout setSpacing(int x, int y) {
      spacingX = x;
      spacingY = y;
      return this;
    }

    public LetterLayout setSpacing(int spacing) {
      return setSpacing(spacing, spacing);
    }

    public LetterLayout setBorder(int top, int left, int bottom, int right) {
      insetTop = top;
      insetLeft = left;
      insetBottom = bottom;
      insetRight = right;
      return this;
    }

    public LetterLayout setBorder(int inset) {
      return setBorder(inset, inset, inset, inset);
    }

    public LetterLayout setTopBorder(int inset) {
      insetTop = inset;
      return this;
    }

    public static LetterLayout stalactite() {
      return new LetterLayout(STALACTITE);
    }

    public static LetterLayout leftAlignedRow() {
      return new LetterLayout(LEFT_ALIGNED_ROW);
    }

    public static LetterLayout leftAlignedRow(int spacing) {
      return leftAlignedRow().setSpacing(spacing);
    }

    public static LetterLayout centeredRow() {
      return new LetterLayout(CENTERED_ROW);
    }

    public static LetterLayout rightAlignedRow() {
      return new LetterLayout(RIGHT_ALIGNED_ROW);
    }

    public static JPanel rightAlignedRowPanel(JComponent... components) {
      return makePanel(new LetterLayout(RIGHT_ALIGNED_ROW), components);
    }

    static public JPanel makePanel(LetterLayout letterLayout, JComponent[] components) {
      JPanel panel = new JPanel(letterLayout);
      for (JComponent component : components) {
        panel.add(component);
      }
      return panel;
    }

    public static LetterLayout form() {
      LetterLayout letterLayout = new LetterLayout(FORM);
      letterLayout.formWideLeftSide = true;
      letterLayout.formWideRightSide = true;
      return letterLayout;
    }

    public static LetterLayout formWideRightSide() {
      LetterLayout letterLayout = new LetterLayout(FORM);
      letterLayout.formWideRightSide = true;
      return letterLayout;
    }

    public static Component getDummyComponent() {
      return new DummyComponent();
    }

    public static JPanel newPanel(String... lines) {
      return new JPanel(new LetterLayout(lines));
    }

    public boolean isDebug() {
      return debug;
    }

    public void setDebug(boolean debug) {
      this.debug = debug;
    }

    public static char makeIndexChar(int idx) {
      return (char) ('a' + idx * 2);
    }

    public static char makeAlternateIndexChar(int idx) {
      return (char) ('b' + idx * 2);
    }

    public static char LEFT_CHAR = ',', RIGHT_CHAR = '.';

    public static void main(String[] args) {
      System.out.println((int) makeIndexChar(0));
      System.out.println((int) makeAlternateIndexChar(0));
      System.out.println((int) makeIndexChar(32000));
      System.out.println((int) makeAlternateIndexChar(32000));
      System.out.println((int) LEFT_CHAR);
      System.out.println((int) RIGHT_CHAR);
    }
  }

  static public GlobalID aGlobalIDObjUnlessLoading() {
    return dynamicObjectIsLoading() ? null : aGlobalIDObj();
  }

  static public Border getBorder(final JComponent c) {
    return c == null ? null : swing(new F0<Border>() {

      public Border get() {
        try {
          return c.getBorder();
        } catch (Exception __e) {
          throw rethrow(__e);
        }
      }

      public String toString() {
        return "return c.getBorder();";
      }
    });
  }

  static public <A, B> Map.Entry<A, B> firstEntry(Map<A, B> map) {
    return empty(map) ? null : first(map.entrySet());
  }

  static public <A extends JComponent> A toolTip(A c, final Object toolTip) {
    return setToolTipText(c, toolTip);
  }

  static public <A extends JComponent> A toolTip(Object toolTip, A c) {
    return setToolTipText(toolTip, c);
  }

  static public <A, B> Map.Entry<A, B> simpleMapEntry(A key, B value) {
    return new Map.Entry<A, B>() {

      public A getKey() {
        return key;
      }

      public B getValue() {
        return value;
      }

      public B setValue(B newValue) {
        throw unimplemented();
      }
    };
  }

  static public <A> float getScore(Scored<A> s) {
    return s == null ? 0 : s.score;
  }

  static public boolean has(String a, String b, String c) {
    return false;
  }

  static public boolean has(T3<String, String, String> t) {
    return false;
  }

  static public String callStringifier(Object stringifier, Object o) {
    return stringifier != null ? str(callF(stringifier, o)) : str(o);
  }

  static public String shortName(Object o) {
    return shortClassName(o);
  }

  static public FunctionCall functionCall_list(Object fname, Iterable args) {
    return new FunctionCall(fname, toObjectArray(args));
  }

  static public double sqrt(double x) {
    return Math.sqrt(x);
  }

  static public double fracNonNeg(double d) {
    return frac_nonNeg(d);
  }

  static public double twoPi() {
    return Math.PI * 2;
  }

  static public String plusPrefixUnlessMinus(String s) {
    return startsWith(s, "-") ? s : "+" + s;
  }

  static public String formatDouble_significant2(double d, int digits) {
    try {
      digits -= max(0, Math.floor(Math.log10(abs(d)) + 1));
      return formatDouble(d, digits);
    } catch (Throwable _e) {
      print("Had number: " + d + ", digits: " + digits);
      throw rethrow(_e);
    }
  }

  static public File pathToJavaxJar() {
    IResourceLoader rl = vm_getResourceLoader();
    if (rl != null)
      return rl.pathToJavaXJar();
    return pathToJavaxJar_noResourceLoader();
  }

  static public File pathToJavaxJar_noResourceLoader() {
    try {
      int x = latestInstalledJavaX();
      File xfile = new File(userHome(), ".javax/x" + Math.max(x, 30) + ".jar");
      if (!xfile.isFile()) {
        print("Saving " + f2s(xfile));
        String url = x30JarServerURL();
        byte[] data = loadBinaryPage(url);
        if (data.length < 1000000)
          throw fail("Could not load " + url);
        saveBinaryFile(xfile.getPath(), data);
      }
      return xfile;
    } catch (Exception __e) {
      throw rethrow(__e);
    }
  }

  static public <A, B> boolean isA(Either<A, B> e) {
    return eitherIsA(e);
  }

  static public String find(String pattern, String text) {
    Matcher matcher = Pattern.compile(pattern).matcher(text);
    if (matcher.find())
      return matcher.group(1);
    return null;
  }

  static public <A> A find(Collection<A> c, Object... data) {
    for (A x : c) if (checkFields(x, data))
      return x;
    return null;
  }

  static public int iceil(double d) {
    return (int) Math.ceil(d);
  }

  static public String shorten_str(Object o) {
    return shorten(str(o));
  }

  static public String shorten_str(Object o, int max) {
    return shorten(str(o), max);
  }

  static public String shorten_str(int max, Object o) {
    return shorten_str(o, max);
  }

  static public Rect rect(int x, int y, int w, int h) {
    return new Rect(x, y, w, h);
  }

  static public Rect rect(Pt p, int w, int h) {
    return new Rect(p.x, p.y, w, h);
  }

  static public Rect rect(int w, int h) {
    return new Rect(0, 0, w, h);
  }

  static public long longMul(long a, long b) {
    return a * b;
  }

  static public boolean isNaN(double d) {
    return Double.isNaN(d);
  }

  static public boolean isNaN(float f) {
    return Float.isNaN(f);
  }

  static public double minusInfinity() {
    return negativeInfinity();
  }

  static public <A> Scored<A> scored(A a, float score) {
    return new Scored(a, score);
  }

  static public <A> Scored<A> scored(A a, double score) {
    return new Scored(a, (float) score);
  }

  static public <A> Scored<A> scored(A a, Scored scored) {
    return new Scored(a, getScore(scored));
  }

  static public <A> Scored<A> scored(double score, A a) {
    return scored(a, score);
  }

  static public JPanel withBorder(javax.swing.border.Border border, final Component c) {
    return swing(new F0<JPanel>() {

      public JPanel get() {
        try {
          JPanel p = new JPanel(new BorderLayout());
          p.setBorder(border);
          p.add(c);
          return p;
        } catch (Exception __e) {
          throw rethrow(__e);
        }
      }

      public String toString() {
        return "JPanel p = new JPanel(new BorderLayout);\r\n    p.setBorder(border);\r\n    p.add...";
      }
    });
  }

  static public int getMinimumHeight(final Component c) {
    return getMinimumSize(c).height;
  }

  static public boolean isOneOfSingleChars(String s, char... chars) {
    if (l(s) != 1)
      return false;
    char real = s.charAt(0);
    for (char c : unnullForIteration(chars)) if (real == c)
      return true;
    return false;
  }

  static public GlobalID aGlobalIDObj() {
    return asGlobalID(randomID(16));
  }

  static public GlobalID aGlobalIDObj(Random random) {
    return asGlobalID(randomID(random, 16));
  }

  static public RuntimeException unimplemented() {
    throw fail("TODO");
  }

  static public RuntimeException unimplemented(String msg) {
    throw fail("TODO: " + msg);
  }

  static public RuntimeException unimplemented(Object obj) {
    throw fail("TODO: implement method in " + className(obj));
  }

  static public double frac_nonNeg(double d) {
    return mod(d, 1);
  }

  static public int latestInstalledJavaX() {
    File[] files = new File(userHome(), ".javax").listFiles();
    int v = 0;
    if (files != null)
      for (File f : files) {
        Matcher m = regexpMatcher("x(\\d\\d\\d?)\\.jar", f.getName());
        if (m.matches())
          v = Math.max(v, Integer.parseInt(m.group(1)));
      }
    return v;
  }

  static public String x30JarServerURL() {
    return "http://botcompany.de:8081/x30.jar";
  }

  static public <A, B> boolean eitherIsA(Either<A, B> e) {
    return e != null && e.isA();
  }

  static public boolean checkFields(Object x, Object... data) {
    for (int i = 0; i < l(data); i += 2) if (neq(getOpt(x, (String) data[i]), data[i + 1]))
      return false;
    return true;
  }

  static public double negativeInfinity() {
    return Double.NEGATIVE_INFINITY;
  }

  static public Dimension getMinimumSize(final Component c) {
    return c == null ? null : swing(new F0<Dimension>() {

      public Dimension get() {
        try {
          return c.getMinimumSize();
        } catch (Exception __e) {
          throw rethrow(__e);
        }
      }

      public String toString() {
        return "return c.getMinimumSize();";
      }
    });
  }

  static public GlobalID asGlobalID(String id) {
    return id == null ? null : new GlobalID(id);
  }

  static public int randomID_defaultLength = 12;

  static public String randomID(int length) {
    return makeRandomID(length);
  }

  static public String randomID(Random r, int length) {
    return makeRandomID(r, length);
  }

  static public String randomID() {
    return randomID(randomID_defaultLength);
  }

  static public String randomID(Random r) {
    return randomID(r, randomID_defaultLength);
  }

  static public int mod(int n, int m) {
    return (n % m + m) % m;
  }

  static public long mod(long n, long m) {
    return (n % m + m) % m;
  }

  static public BigInteger mod(BigInteger n, int m) {
    return n.mod(bigint(m));
  }

  static public double mod(double n, double m) {
    return (n % m + m) % m;
  }

  static public class T3<A, B, C> {

    public A a;

    public B b;

    public C c;

    public T3() {
    }

    public T3(A a, B b, C c) {
      this.c = c;
      this.b = b;
      this.a = a;
    }

    public T3(T3<A, B, C> t) {
      a = t.a;
      b = t.b;
      c = t.c;
    }

    public int hashCode() {
      return _hashCode(a) + 2 * _hashCode(b) - 4 * _hashCode(c);
    }

    public boolean equals(Object o) {
      if (o == this)
        return true;
      if (!(o instanceof T3))
        return false;
      T3 t = (T3) o;
      return eq(a, t.a) && eq(b, t.b) && eq(c, t.c);
    }

    public String toString() {
      return "(" + quoteBorderless(a) + ", " + quoteBorderless(b) + ", " + quoteBorderless(c) + ")";
    }
  }

  static public String quoteBorderless(Object o) {
    if (o == null)
      return "null";
    return quoteBorderless(str(o));
  }

  static public String quoteBorderless(String s) {
    if (s == null)
      return "null";
    StringBuilder out = new StringBuilder((int) (l(s) * 1.5));
    quoteBorderless_impl(s, out);
    return out.toString();
  }

  static public void quoteBorderless_impl(String s, StringBuilder out) {
    int l = s.length();
    for (int i = 0; i < l; i++) {
      char c = s.charAt(i);
      if (c == '\\' || c == '"')
        out.append('\\').append(c);
      else if (c == '\r')
        out.append("\\r");
      else if (c == '\n')
        out.append("\\n");
      else
        out.append(c);
    }
  }
}