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 java.lang.invoke.VarHandle;
import java.lang.invoke.MethodHandles;


import java.awt.geom.*;
import java.text.SimpleDateFormat;
import java.nio.charset.Charset;
import java.util.*;
import java.io.*;
import java.net.*;
import java.nio.channels.FileChannel;
import java.security.KeyStore;
import java.util.logging.Level;
import java.util.logging.Logger;
import java.util.regex.Matcher;
import java.util.regex.Pattern;
import java.util.zip.GZIPOutputStream;
import javax.net.ssl.*;
import static x30_pkg.x30_util.DynamicObject;
import java.nio.charset.*;
import java.nio.*;
import java.nio.file.*;
import static java.nio.file.StandardWatchEventKinds.*;
import javax.net.*;
import com.google.api.client.googleapis.auth.oauth2.GoogleIdToken;
import com.google.api.client.googleapis.auth.oauth2.GoogleIdToken.Payload;
import com.google.api.client.googleapis.auth.oauth2.GoogleIdTokenVerifier;
import com.google.api.client.json.jackson2.JacksonFactory;
import com.google.api.client.http.javanet.NetHttpTransport;
import java.awt.datatransfer.StringSelection;
import java.nio.file.Path;
import javax.swing.border.*;
import javax.swing.event.AncestorListener;
import javax.swing.event.AncestorEvent;
import javax.swing.Timer;
import java.text.*;
import java.text.NumberFormat;
import javax.swing.undo.UndoManager;
import java.util.TimeZone;
import javax.imageio.metadata.*;
import javax.imageio.stream.*;
import java.security.Principal;
import java.security.PrivateKey;
import java.security.cert.X509Certificate;
import javax.swing.Icon;
import java.awt.datatransfer.*;
import java.awt.datatransfer.Transferable;
import java.awt.datatransfer.DataFlavor;
import java.awt.datatransfer.UnsupportedFlavorException;

class main {

static class Domain extends Concept {
  static final String _fieldOrder = "domain moduleLibID proxyDestination proxyCookieChecker proxyRewritePort mustBeEnabled";
  String domain;
  String moduleLibID;
  String proxyDestination;
  String proxyCookieChecker; // a module lib ID
  boolean proxyRewritePort = false;
  boolean mustBeEnabled = false;
  
  public String toString() { return super.toString() + " " + domain; }
}

// Eleu is so important, we don't use a shared lib
static class Eleu3 extends DynEleu {
  transient CRUD<Domain> domainCRUD;
  static boolean _switchableField_verbose = true; boolean verbose = false;
  static boolean _switchableField_debugNanoHTTPD = true; boolean debugNanoHTTPD = false;
  static boolean _switchableField_sameSite = true; String sameSite;
  
  {} { enabled = false; }
  
  void start() { try { super.start();
    NanoHTTPD_debug = debugNanoHTTPD;
    //bootstrapDBFrom(#1029618);
    dbIndexingCI(Domain.class, "domain");
    //assertNempty(list(Domain));
    uniqCI(Domain.class, "domain" , "<default>");
    domainCRUD = new CRUD(Domain.class);
    //dm_registerAs eleuWithCRUD();
  } catch (Exception __e) { throw rethrow(__e); } }
  
  public JComponent visualize() {
    var c = jtabs(
     "Main", super.visualize(),
      "Domains" , domainCRUD.visualize());
      
    tablePopupMenu(domainCRUD.table(), new VF2<JPopupMenu, Integer>() { public void get(JPopupMenu menu, Integer row) { try { 
      Domain d = domainCRUD.selected(); if (d == null) return;
      if (nempty(d.moduleLibID))
        addMenuItem(menu, "Load module", runnableThread(new Runnable() {  public void run() { try {   AutoCloseable __2 = enter(); try {  dm_makeOrShow(d.moduleLibID) ;
} finally { _close(__2); }} catch (Exception __e) { throw rethrow(__e); } }  public String toString() { return "temp enter();  dm_makeOrShow(d.moduleLibID)"; }}));
     } catch (Exception __e) { throw rethrow(__e); } }
  public String toString() { return "Domain d = domainCRUD.selected(), ret if null;\r\n      if (nempty(d.moduleLibI..."; }});
    
    return c;
  }
  
  @Override 
  String moduleForDomain(String domain) {
    domain = dropAfterColon(domain); // drop port number
    for (Domain d : domainsInMatchingOrder()) {
      if (matchingDomain(d, domain)) {
        String mod = findMod(d);
        if (verbose) print("Domain matched: " + domain + " / " + d.domain + " => " + mod); 
        { String __1 = mod; if (!empty(__1)) return __1; }
      } else
        if (verbose) print("Domain not matched: " + domain + " / " + d.domain); 
    }
    return findMod(defaultDomain());
  }
  
  Domain defaultDomain() {
    return conceptWhereCI(Domain.class, "domain" , "<default>");
  }
  
  String findMod(Domain d) {
    if (d == null || empty(d.moduleLibID)) return null;
    return d.mustBeEnabled
      ? dm_findModuleWithParams(d.moduleLibID, "enabled" , true)
      : dm_findModule(d.moduleLibID);
  }

  ServeHttp_CookieHandler makeCookieHandler() {
    ServeHttp_CookieHandler cookieHandler = super.makeCookieHandler();
    cookieHandler.metaParams = appendPrefixIfNempty("SameSite=", sameSite);
    return cookieHandler;
  }
  
  void onWebServersStarted() { super.onWebServersStarted();
    forEach(webServers(), ws -> {
      print("Augmenting web server: " + ws);
      
      ws.collectHeaderLines = true;
      
      // session is an instance of NanoHTTPD.IHTTPSession
      ws.specialHandling = session -> { try {
         AutoCloseable __3 = enter(); try {
        String domain = dropPortFromHost(mapGet(session.getHeaders(), "host"));

        Domain d = first(domainsInMatchingOrder(), 
          _d -> matchingDomain(_d, domain));
          
        printVars("domain", domain, "d", d);
        if (d == null || empty(d.proxyDestination)) return false;
        print("Handling proxy request to " + d.proxyDestination);
        HostAndPort hap = new HostAndPort(d.proxyDestination);
        
        if (nempty(d.proxyCookieChecker)) {
          String cookieChecker = dm_findModule(d.proxyCookieChecker);
          if (empty(cookieChecker))
            throw fail(print("Cookie checker " + d.proxyCookieChecker + " not found, aborting request"));
            
          NanoHTTPD.CookieHandler cookies = session.getCookies();
          
          if (!isTrue(dm_call(cookieChecker, "checkCookie", cookies.read("cookie"), domain)))
            throw fail(print("Cookie checker disapproves"));
          else
            print("Cookie checker approves. URI: " + session.getUri());
        }
        
        HandleProxyRequest hpr = new HandleProxyRequest();
        hpr.hap = hap;
        hpr.session = session;
        hpr.rewritePort = d.proxyRewritePort;
        
        hpr.customizeRequest = proxyRequest -> {
          proxyRequest.setOut = out -> {
            proxyRequest.setOut_base(out);
            proxyRequest.outProxied = out; // mod here
          };
          
          proxyRequest.setOutOut = outOut -> {
            proxyRequest.setOutOut_base(outOut);
            proxyRequest.outOutProxied = outOut; // mod here
          };
        };
        
        vmBus_send("handlingProxyRequest", me(), hpr);
        
        { hpr.run(); return true; }
      } finally { _close(__3); }} catch (Exception __e) { throw rethrow(__e); } };
    });
  } // onWebServersStarted
  
  boolean matchingDomain(Domain d, String domain) {
    return domainIsUnder_extended(domain, d.domain);
  }
  
  class WebRequest2 extends WebRequest {
    WebRequest2(NanoHTTPD.IHTTPSession httpSession, String uri, Map<String, String> params) {
      super(httpSession, uri, params);
    }
    
    // TODO: change uri etc
    /*public NanoHTTPD.Response proxy(S url, bool rewriteHost, bool rewritePort) {
      url = dropPrefix("http://", url);
      if (startsWith(url, "https://"))
      new HandleProxyRequest hpr;
      hpr.hap = hap;
      hpr.session = httpSession;
      hpr.rewriteHost = rewriteHost;
      hpr.rewritePort = rewritePort;
      hpr.run();
      null;
    }*/
  }

  @Override
  WebRequest createWebRequest(NanoHTTPD.IHTTPSession httpSession,
    String uri, Map<String, String> params) {
    return new WebRequest2(httpSession, uri, params);
  }

  // API
  
  Collection<Domain> domainsInMatchingOrder() {
    return sortByCalculatedFieldICDesc(
      filter(list(Domain.class), d -> !eqic(d.domain, "<default>")),
      d -> reversed(d.domain));
  }
  
  void addDomain(String domain, String moduleLibID, boolean mustBeEnabled) {
    uniq(Domain.class, "domain", domain, "moduleLibID", moduleLibID, "mustBeEnabled", mustBeEnabled);
  }
}
static boolean _moduleClass_Eleu3 = true;
static void dbIndexingCI(Object... params) {
  db();
  indexConceptFieldsCI(itemPlusArray(db_mainConcepts(), params));
}


static <A extends Concept> A uniqCI(Class<A> c, Object... params) {
  return uniqueConcept(db_mainConcepts(), c, params);
}

static <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 RuntimeException rethrow(Throwable t) {
  
  if (t instanceof Error)
    _handleError((Error) t);
  
  throw t instanceof RuntimeException ? (RuntimeException) t : new RuntimeException(t);
}

static RuntimeException rethrow(String msg, Throwable t) {
  throw new RuntimeException(msg, t);
}


// x = names and components interleaving.
// or just components.
// or just names.
// also, first element can be index of tab to open at start
// also, SUPER short demo syntax: jtabs(3)
// also, you can pass a Collection containing the elements
static JTabbedPane jtabs(Object... x) {
  return fillJTabs(swingNu(JTabbedPane.class), x);
}


static class tablePopupMenu_Maker {
  List menuMakers = new ArrayList();
}

static Map<JTable, tablePopupMenu_Maker> tablePopupMenu_map = newWeakHashMap();

static ThreadLocal<MouseEvent> tablePopupMenu_mouseEvent = new ThreadLocal();
static ThreadLocal<Boolean> tablePopupMenu_first = new ThreadLocal();

// menuMaker = voidfunc(JPopupMenu, int row)
static void tablePopupMenu(final JTable table, final Object menuMaker) {
  final boolean first = isTrue(getAndClearThreadLocal(tablePopupMenu_first));
  { swing(() -> { 
    tablePopupMenu_Maker maker = tablePopupMenu_map.get(table);
    if (maker == null) {
      tablePopupMenu_map.put(table, maker = new tablePopupMenu_Maker());
      final tablePopupMenu_Maker _maker = maker;
      table.addMouseListener(new MouseAdapter() {
        public void mousePressed(MouseEvent e) { displayMenu(e); }
        public void mouseReleased(MouseEvent e) { displayMenu(e); }
      
        void displayMenu(MouseEvent e) {
          if (!e.isPopupTrigger()) return;
          JPopupMenu menu = new JPopupMenu();
          int row = table.rowAtPoint(e.getPoint());
          if (table.getSelectedRowCount() < 2)
            table.setRowSelectionInterval(row, row);
          int modelRow = convertTableRowToModel(table, row);
          int emptyCount = menu.getComponentCount();
          
          tablePopupMenu_mouseEvent.set(e);
          for (Object menuMaker : _maker.menuMakers)
            pcallF(menuMaker, menu, modelRow);
            
          vmBus_send("showingPopupMenu", table, menu);
          
          // show menu if any items in it
          if (menu.getComponentCount() != emptyCount)
            menu.show(e.getComponent(), e.getX(), e.getY());
        }
      });
    }
    if (first)
      maker.menuMakers.add(0, menuMaker);
    else
      maker.menuMakers.add(menuMaker);
  }); }
}


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

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

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

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

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

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


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



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









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



static boolean nempty(CloseablesHolder ch) { return ch != null && !empty(ch.closeables); }



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


static boolean nempty(IntSize l) { return l != null && l.size() != 0; }


static void addMenuItem(JPopupMenu menu, String text, Object action) {
  menu.add(jmenuItem(text, action));
}

static void addMenuItem(JPopupMenu menu, JMenuItem menuItem) {
  if (menu != null && menuItem != null)
    menu.add(menuItem);
}

static void addMenuItem(JMenu menu, String text, Object action) {
  menu.add(jmenuItem(text, action));
}

static void addMenuItem(Menu menu, String text, Object action) {
  menu.add(menuItem(text, action));
}

static void addMenuItem(JMenu menu, JMenuItem menuItem) {
  menu.add(menuItem);
}

static void addMenuItem(JMenuBar menuBar, String text, Runnable action) {
  addMenuItem(menuBar, jmenuItem(text, action));
}

static void addMenuItem(JMenuBar menuBar, JMenuItem menuItem) {
  addDirectMenuItem(menuBar, menuItem);
}


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


// makes dynamic & static modules
static String dm_makeOrShow(String moduleLibID) {
  return dm_makeOrShowModule(moduleLibID);
}


static void _close(AutoCloseable c) {
  if (c != null) try {
    c.close();
  } catch (Throwable e) {
    // Some classes stupidly throw an exception on double-closing
    if (c instanceof javax.imageio.stream.ImageOutputStream)
      return;
    else throw rethrow(e);
  }
}


static String dropAfterColon(String s) {
  return dropAfterFirstColon(s);
}


static volatile StringBuffer local_log = new StringBuffer(); // not redirected




static boolean printAlsoToSystemOut = true;

static volatile Appendable print_log = local_log; // might be redirected, e.g. to main bot

// in bytes - will cut to half that
static volatile int print_log_max = 1024*1024;
static volatile int local_log_max = 100*1024;

static boolean print_silent = false; // total mute if set

static Object print_byThread_lock = new Object();
static volatile ThreadLocal<Object> print_byThread; // special handling by thread - prefers F1<S, Bool>
static volatile Object print_allThreads;
static volatile Object print_preprocess;

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

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

// slightly overblown signature to return original object...
static <A> A print(A o) {
  ping_okInCleanUp();
  if (print_silent) return o;
  String s = o + "\n";
  print_noNewLine(s);
  return o;
}

static void print_noNewLine(String s) {
  
  try {
    Object f = getThreadLocal(print_byThread_dontCreate());
    if (f == null) f = print_allThreads;
      if (f != null)
        // We do need the general callF machinery here as print_byThread is sometimes shared between modules
        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 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 void print_autoRotate() {
  
}


static boolean empty(Collection c) { return c == null || c.isEmpty(); }
static boolean empty(Iterable c) { return c == null || !c.iterator().hasNext(); }
static boolean empty(CharSequence s) { return s == null || s.length() == 0; }
static boolean empty(Map map) { return map == null || map.isEmpty(); }
static boolean empty(Object[] o) { return o == null || o.length == 0; }
static boolean empty(BitSet bs) { return bs == null || bs.isEmpty(); }


static 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 boolean empty(Iterator i) { return i == null || !i.hasNext(); }

static boolean empty(double[] a) { return a == null || a.length == 0; }
static boolean empty(float[] a) { return a == null || a.length == 0; }
static boolean empty(int[] a) { return a == null || a.length == 0; }
static boolean empty(long[] a) { return a == null || a.length == 0; }
static boolean empty(byte[] a) { return a == null || a.length == 0; }
static boolean empty(short[] a) { return a == null || a.length == 0; }


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



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


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






















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



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



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


static boolean empty(IntSize l) { return l == null || l.size() == 0; }


static <A extends Concept> A conceptWhereCI(Class<A> c, Object... params) {
  return findConceptWhereCI(c, params);
}

static Concept conceptWhereCI(String c, Object... params) {
  return findConceptWhereCI(db_mainConcepts(), c, params);
}

static <A extends Concept> A conceptWhereCI(Concepts concepts, Class<A> c, Object... params) {
  return findConceptWhereCI(concepts, c, params);
}

static Concept conceptWhereCI(Concepts concepts, String c, Object... params) {
  return findConceptWhereCI(concepts, c, params);
}


static String dm_findModuleWithParams(String moduleLibID, Object... params) {
  return firstThat(dm_modulesWithLibID(moduleLibID), mod ->
    checkFields(dm_mod(mod), params));
}


// dynamic only for now
static String dm_findModule(String moduleLibID) {
  return (String) callCreator("findModuleByLibID", moduleLibID);
}


static String appendPrefixIfNempty(String prefix, String s) {
  return prependIfNempty(prefix, s);
}


static <A> void forEach(Iterable<A> l, IVF1<A> f) {
  if (f != null && l != null) for (A a : l)
    callF(f, a);
}

static <A> void forEach(IVF1<A> f, Iterable<A> l) {
  forEach(l, f);
}

static <A> void forEach(A[] l, IVF1<A> f) {
  if (f != null && l != null) for (A a : l)
    callF(f, a);
}

static <A> void forEach(IVF1<A> f, A[] l) {
  forEach(l, f);
}

static <A, B> void forEach(Map<A, B> map, IVF2<A, B> f) {
  for (Map.Entry<? extends A, ? extends B> __0 : _entrySet( map))
    { A a = __0.getKey(); B b = __0.getValue();  f.get(a, b); }
}


static String dropPortFromHost(String s) {
  return beforeColonOrAll(s);
}


static <A, B> B mapGet(Map<A, B> map, A a) {
  return map == null || a == null ? null : map.get(a);
}

static <A, B> B mapGet(A a, Map<A, B> map) {
  return map == null || a == null ? null : map.get(a);
}



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


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

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

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

static <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 <A> A first(IterableIterator<A> i) {
  return first((Iterator<A>) i);
}


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

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

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


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



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


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





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

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

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


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



static <A> A first(IMultiSet<A> a) {
  return a == null ? null : first(a.keySet());
}



// Use like this: printVars(+x, +y);
// Or: printVars("bla", +x);
// Or: printVars bla(, +x);
static void printVars(Object... params) {
  printVars_str(params);
}


static RuntimeException fail() { throw new RuntimeException("fail"); }
static RuntimeException fail(Throwable e) { throw asRuntimeException(e); }
static RuntimeException fail(Object msg) { throw new RuntimeException(String.valueOf(msg)); }


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


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



static boolean isTrue(Object o) {
  if (o instanceof Boolean)
    return ((Boolean) o).booleanValue();
  if (o == null) return false;
  if (o instanceof ThreadLocal) // TODO: remove this
    return isTrue(((ThreadLocal) o).get());
  throw fail(getClassName(o));
}

static boolean isTrue(Boolean b) {
  return b != null && b.booleanValue();
}


static Object dm_call(Object moduleOrID, String method, Object... args) {
  Object mod = dm_getModule(moduleOrID);
  if (mod == null) return null;
   AutoCloseable __1 = dm_enter(mod); try {
  return call_withVarargs(mod, method, args);
} finally { _close(__1); }}


static 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 void vmBus_send(String msg) {
  vmBus_send(msg, (Object) null);
}


static boolean domainIsUnder_extended(String domain, String mainDomain) {
  Matches m = new Matches();
  if (startsWith(mainDomain, "@.", m))
    return eqic(domain, m.rest());
  if (startsWith(mainDomain, "*"))
    return ewic(domain, substring(mainDomain, 1));
  return domainIsUnder(domain, mainDomain);
}


static <A> List<A> sortByCalculatedFieldICDesc(Iterable<A> c, IF1<A, String> f) {
  List<A> l = cloneList(c);
  sort(l, (b, a) -> compareIC(f.get(a), f.get(b)));
  return l;
}


static <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 List filter(Object pred, Iterable c) {
  return filter(c, pred);
}

static <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 <A, B extends A> List<B> filter(F1<A, Boolean> pred, Iterable<B> c) {
  return filter(c, pred);
}

//ifclass IF1
static <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 <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 <A, B extends A> List<B> filter(IF1<A, Boolean> pred, Iterable<B> c) {
  return filter(c, pred);
}
//endif


static <A extends Concept> List<A> list(Class<A> type) { return list(type, db_mainConcepts()); }
static <A extends Concept> List<A> list(Class<A> type, Concepts cc) {
  return cc.list(type);
}

static <A extends Concept> List<A> list(Concepts concepts, Class<A> type) {
  return concepts.list(type);
}

static List<Concept> list(String type) {
  return db_mainConcepts().list(type);
}

static List<Concept> list(Concepts concepts, String type) {
  return concepts.list(type);
}

static List<Concept> list(Concepts concepts) {
  return asList(concepts.allConcepts());
}



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


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

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


static 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 <A> List<A> reversed(Iterable<A> l) {
  return reversedList(l);
}

static <A> List<A> reversed(A[] l) {
  return reversedList(asList(l));
}

static String reversed(String s) {
  return reversedString(s);
}


static <A extends Concept> A uniq(Class<A> c, Object... params) {
  return uniqueConcept(c, params);
}

static <A extends Concept> A uniq(Concepts cc, Class<A> c, Object... params) {
  return uniqueConcept(cc, c, params);
}




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


static void db() {
  conceptsAndBot();
}

// use -10000 for 10 seconds plus slowdown logic
static void db(Integer autoSaveInterval) {
  conceptsAndBot(autoSaveInterval);
}


// first parameter can be Concepts
static void indexConceptFieldsCI(Object... params) {
  int i = 0;
  Concepts concepts;
  if (first(params) instanceof Concepts) {
    concepts = (Concepts) first(params);
    ++i;
  } else concepts = db_mainConcepts();
  for (; i < l(params); i += 2)
    indexConceptFieldCI(concepts, (Class) params[i], (String) params[i+1]);
}


static <A> A[] itemPlusArray(A a, A[] l) {
  return singlePlusArray(a, l);
}


static volatile Concepts mainConcepts; // Where we create new concepts

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

static void cleanMeUp_concepts() {
  if (db_mainConcepts() != null) db_mainConcepts().cleanMeUp();
  // mainConcepts = null; // TODO
}



static <A extends Concept> A uniqueConcept(Class<A> c, Object... params) {
  return uniqueConcept(db_mainConcepts(), c, params);
}

static <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 AutoCloseable tempDBLock(Concepts concepts) {
  return tempLock(concepts.lock); // NO null propagation this time
}

static AutoCloseable tempDBLock() {
  return tempDBLock(db_mainConcepts());
}


static <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 <A extends Concept> A findConceptWhereCI(Class<A> c, Object... params) {
  return findConceptWhereCI(db_mainConcepts(), c, params);
}

static <A extends Concept> A findConceptWhereCI(Concepts concepts, Class<A> c, Object... params) {
  params = expandParams(c, params);
  
  // find smallest index to use
  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) {
        // conservatively use full ref count as score until we store backRefs by class
        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); // nothing to filter, index should suffice
    for  (A x : l)
      { ping(); if (checkConceptFieldsIC(x, params)) return x; }
    return null;
  } else {
    // table scan
    for  (A x : concepts.list(c))
      { ping(); if (checkConceptFieldsIC(x, params)) return x; }
    return null;
  }
}

static Concept findConceptWhereCI(Concepts concepts, String c, Object... params) {
  for  (Concept x : concepts.list(c))
    { ping(); if (checkConceptFieldsIC(x, params)) return x; }
  return null;
}



// make concept instance that is not connected to DB
static <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 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 int csetAll(Concept c, Object... values) {
  return cset(c, values);
}

static int csetAll(Iterable<? extends Concept> l, Object... values) {
  int n = 0;
  for (Concept c : unnullForIteration(l))
    n += cset(c, values);
  return n;
}

static 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 void _handleError(Error e) {
  //call(javax(), '_handleError, e);
}


// x = names and components interleaving.
// or just components.
// or just names.
// also, first element can be index of tab to open at start
// also, SUPER short demo syntax: jtabs(3)
// also, you can pass a Collection containing the elements
static 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;
    
    // is it a component?
    Object o = x[i];
    if (isComponentOrSwingable(o))
      addTab(tabs, "Tab " + n, wrap(o));
    else {
      // assume it's a tab name, optionally followed by a component
      String toolTip = "";
      
      // WithToolTip<S> is ok (WithToolTip<Component> not yet supported)
      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 <A> A swingNu(final Class<A> c, final Object... args) {
  return swingConstruct(c, args);
}


static <A, B> Map<A, B> newWeakHashMap() {
  return _registerWeakMap(synchroMap(new WeakHashMap()));
}


static <A> A getAndClearThreadLocal(ThreadLocal<A> tl) {
  A a = tl.get();
  tl.set(null);
  return a;
}


static Object swing(Object f) {
  return swingAndWait(f);
}

static void swing(Runnable f) {
  swingAndWait(f);
}

static <A> A swing(F0<A> f) {
  return (A) swingAndWait(f);
}

static <A> A swing(IF0<A> f) {
  return (A) swingAndWait(f);
}


static int convertTableRowToModel(final JTable t, final int viewRow) {
  return t == null || viewRow < 0 ? -1 : swing(new F0<Integer>() { public Integer get() { try { 
    return t.convertRowIndexToModel(viewRow);
   } catch (Exception __e) { throw rethrow(__e); } }
  public String toString() { return "return t.convertRowIndexToModel(viewRow);"; }});
}


static Object pcallF(Object f, Object... args) {
  return pcallFunction(f, args);
}


static <A> A pcallF(F0<A> f) {
  try { return f == null ? null : f.get(); } catch (Throwable __e) { pcallFail(__e); } return null;
}



static <A, B> B pcallF(F1<A, B> f, A a) {
  try { return f == null ? null : f.get(a); } catch (Throwable __e) { pcallFail(__e); } return null;
}



static <A> void pcallF(VF1<A> f, A a) {
  try {
    { if (f != null) f.get(a); }
  } catch (Throwable __e) { pcallFail(__e); }
}


static Object pcallF(Runnable r) {
  try { { if (r != null) r.run(); } } catch (Throwable __e) { pcallFail(__e); } return null;
}

static <A> A pcallF(IF0<A> f) {
  try { return f == null ? null : f.get(); } catch (Throwable __e) { pcallFail(__e); } return null;
}

static <A, B> B pcallF(IF1<A, B> f, A a) {
  try { return f == null ? null : f.get(a); } catch (Throwable __e) { pcallFail(__e); } return null;
}



static boolean jmenuItem_newThreads = false;

static JMenuItem jmenuItem(final String text) {
  return jMenuItem(text, null);
}

static 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 MenuItem menuItem(String text, final Object r) {
  MenuItem mi = new MenuItem(text);
  mi.addActionListener(actionListener(r));
  return mi;
}

static MenuItem menuItem(String text, Runnable r) {
  MenuItem mi = new MenuItem(text);
  mi.addActionListener(actionListener(r));
  return mi;
}


static void addDirectMenuItem(JMenuBar mb, String text, Object action) {
  if (mb != null) { swing(() -> { 
    addDirectMenuItem(mb, directJMenuItem(text, action));
  }); }
}

static void addDirectMenuItem(Component c, String text, Object action) {
  addDirectMenuItem(addMenuBar(c), text, action);
}

static void addDirectMenuItem(JMenuBar mb, JMenuItem menuItem) {
  if (mb != null) { swing(() -> { 
    mb.add(menuItem);
    revalidate(mb);
  }); }
}


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

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

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

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


// makes dynamic & static modules
static String dm_makeOrShowModule(String moduleLibID) {
  return (String) dm_callOS("makeOrShowModule", moduleLibID);
}


static String dropAfterFirstColon(String s) {
  if (s == null) return null;
  int i = s.indexOf(':');
  return i < 0 ? s : rtrim(substring(s, 0, i));
}


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


static void ping_okInCleanUp() {


  if (ping_pauseAll || ping_anyActions)
    ping_impl(true);


}


// this syntax should be removed...
static Object getThreadLocal(Object o, String name) {
  ThreadLocal t =  (ThreadLocal) (getOpt(o, name));
  return t != null ? t.get() : null;
}

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

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


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


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



static Map<Class, ArrayList<Method>> callF_cache = newDangerousWeakHashMap();



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



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



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



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


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


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



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



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


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

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


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


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

static Object safeCallF(Object f, Object... args) {
  if (f instanceof Runnable) {
    ((Runnable) f).run();
    return null;
  }
  if (f == null) return null;
  
  Class c = f.getClass();
  ArrayList<Method> methods;
  synchronized(callF_cache) {
    methods = callF_cache.get(c);
    if (methods == null)
      methods = callF_makeCache(c);
  }
  
  int n = l(methods);
  if (n == 0) {
    
    
    if (f instanceof String)
      throw fail("Legacy call: " + f);
    
    throw fail("No get method in " + getClassName(c));
  }
  if (n == 1) return invokeMethod(methods.get(0), f, args);
  for (int i = 0; i < n; i++) {
    Method m = methods.get(i);
    if (call_checkArgs(m, args, false))
      return invokeMethod(m, f, args);
  }
  throw fail("No matching get method in " + getClassName(c));
}

// used internally
static ArrayList<Method> callF_makeCache(Class c) {
  ArrayList<Method> l = new ArrayList();
  Class _c = c;
  do {
    for (Method m : _c.getDeclaredMethods())
      if (m.getName().equals("get")) {
        makeAccessible(m);
        l.add(m);
      }
    if (!l.isEmpty()) break;
    _c = _c.getSuperclass();
  } while (_c != null);
  callF_cache.put(c, l);
  return l;
}





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

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

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

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


static 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 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 Class mc() {
  return main.class;
}


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


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

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


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

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

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

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



static List<String> dm_modulesWithLibID(final String moduleLibID) {
  return filter(dm_moduleIDs() , new F1<String, Boolean>() { public Boolean get(String m) { try {  return eq(dm_moduleLibID(m), moduleLibID);  } catch (Exception __e) { throw rethrow(__e); } }
  public String toString() { return "eq(dm_moduleLibID(m), moduleLibID)"; }});
}


static 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 Object dm_mod(Object moduleOrID) {
  return dm_getModule(moduleOrID);
}


static Object callCreator(String functionName, Object... args) {
  return call(creator(), functionName, args);
}


static String prependIfNempty(String prefix, String s) {
  return empty(s) ? unnull(s) : prefix + s;
}


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


static String beforeColonOrAll(String s) {
  return takeFirst(smartIndexOf(s, ':'), s);
}


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


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


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

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


// Use like this: printVars_str(+x, +y);
// Or: printVars("bla", +x);
// Or: printVars bla(+x);
static void printVars_str(Object... params) {
  print(renderVars_str(params));
}


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


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


static Object dm_getModule(Object moduleOrID) {
  if (moduleOrID == null || eq(moduleOrID, "")) return null;
  if (isString(moduleOrID) && isIdentifier(((String) moduleOrID)))
    return dm_getService(((String) moduleOrID));
  if (isStringOrIntOrLong(moduleOrID))
    return dm_callOS("getDynModuleByID", str(moduleOrID));
  return dm_resolveModule(moduleOrID);
}


static AutoCloseable dm_enter(Object mod) {
  return (AutoCloseable) callOpt(dm_getModule(mod), "enter");
}


static 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);
      
    // try varargs
    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 + "(" + formatArgumentClasses(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);
      
    // try varargs
    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 + "(" + formatArgumentClasses(args) + ") not found");
  }
} catch (Exception __e) { throw rethrow(__e); } }


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


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

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


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

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


static Map<String, Set> vm_busListenersByMessage_live_cache;
static 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 Map<String, Set> vm_busListenersByMessage_live_load() {
  return vm_generalHashMap("busListenersByMessage");
}


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

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


  static 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 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 boolean ewic(String a, String b) {
  return endsWithIgnoreCase(a, b);
}


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



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

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



// convenience method for quickly dropping a prefix
static String substring(String s, CharSequence l) {
  return substring(s, lCharSequence(l));
}


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


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

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


static <T> void sort(T[] a, Comparator<? super T> c) {
  if (a != null) Arrays.sort(a, c);
}

static <T> void sort(T[] a) {
  if (a != null) Arrays.sort(a);
}

static void sort(int[] a) { if (a != null) Arrays.sort(a); }

static <T> void sort(List<T> a, Comparator<? super T> c) {
  if (a != null) Collections.sort(a, c);
}

static void sort(List a) {
  if (a != null) Collections.sort(a);
}


static int compareIC(String s1, String s2) {
  return compareIgnoreCase_jdk(s1, s2);
}


// unclear semantics as to whether return null on null

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

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

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

static 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 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 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 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 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 <A> ArrayList<A> asList(Iterator<A> it) {
  ArrayList l = new ArrayList();
  if (it != null)
    while (it.hasNext())
      l.add(it.next());
  return l;  
}

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

static <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 <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 <A> ArrayList<A> asList(Enumeration<A> e) {
  ArrayList l = new ArrayList();
  if (e != null)
    while (e.hasMoreElements())
      l.add(e.nextElement());
  return l;
}


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



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



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


// a little kludge for stuff like eq(symbol, "$X")
static boolean eq(Symbol a, String b) {
  return eq(str(a), b);
}



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


static <A> List<A> reversedList(Iterable<A> l) {
  List<A> x = cloneList(l);
  Collections.reverse(x);
  return x;
}


static String reversedString(String s) {
  return reverseString(s);
}




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


// f can return false to suppress regular printing
// call print_raw within f to actually print something
static AutoCloseable tempInterceptPrint(F1<String, Boolean> f) {
  return tempSetThreadLocal(print_byThread(), f);
}


volatile static boolean conceptsAndBot_running = false;
static boolean conceptsAndBot_thinOnStart = true;

static void conceptsAndBot() {
  conceptsAndBot(null);
}

static void conceptsAndBot(Integer autoSaveInterval) {
  if (conceptsAndBot_running) return;
  conceptsAndBot_running = true;
  
  Concepts cc = db_mainConcepts();
  cc.programID = getDBProgramID();
  
  try {
    if (cc.useFileLock) {
      if (!cc.fileLock().tryToLock()) {
        ensureDBNotRunning(dbBotStandardName());
        cc.fileLock().forceLock();
      }
    } else
      ensureDBNotRunning(dbBotStandardName());
  } catch (Throwable e) { printStackTrace(e);
    cc.dontSave = true; // SAFETY
  
throw rethrow(e); }
  
  cc.persist(autoSaveInterval);
  dbBot(false);
  
  if (conceptsAndBot_thinOnStart) { try {
    thinAProgramsBackups(getDBProgramID(), true);
  } catch (Throwable __e) { pcallFail(__e); }}
}


static int l(Object[] a) { return a == null ? 0 : a.length; }
static int l(boolean[] a) { return a == null ? 0 : a.length; }
static int l(byte[] a) { return a == null ? 0 : a.length; }
static int l(short[] a) { return a == null ? 0 : a.length; }
static int l(long[] a) { return a == null ? 0 : a.length; }
static int l(int[] a) { return a == null ? 0 : a.length; }
static int l(float[] a) { return a == null ? 0 : a.length; }
static int l(double[] a) { return a == null ? 0 : a.length; }
static int l(char[] a) { return a == null ? 0 : a.length; }
static int l(Collection c) { return c == null ? 0 : c.size(); }

static int l(Iterator i) { return iteratorCount_int_close(i); } // consumes the iterator && closes it if possible

static int l(Map m) { return m == null ? 0 : m.size(); }
static int l(CharSequence s) { return s == null ? 0 : s.length(); }
static long l(File f) { return f == null ? 0 : f.length(); }




  static int l(IMultiSet ms) { return ms == null ? 0 : ms.size(); }



  static int l(IMultiMap mm) { return mm == null ? 0 : mm.size(); }



















  static int l(IntSize o) { return o == null ? 0 : o.size(); }




static <A extends Concept> ConceptFieldIndexCI<A> indexConceptFieldCI(Class<A> c, String field) {
  return indexConceptFieldCI(db_mainConcepts(), c, field);
}

static <A extends Concept> ConceptFieldIndexCI<A> indexConceptFieldCI(Concepts concepts, Class<A> c, String field) {
  ConceptFieldIndexCI<A> idx = getConceptFieldCIIndex(concepts, c, field);
  return idx != null ? idx : new ConceptFieldIndexCI(concepts, c, field);
}


static <A> A[] singlePlusArray(A a, A[] l) {
  A[] out = newObjectArrayOfSameType(l, l(l)+1);
  out[0] = a;
  arraycopy(l, 0, out, 1, l(l));
  return out;
}


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

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

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


static String getDBProgramID_id;

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


// TODO: if field is a Ref<>, you can thoretically use findBackRefs

static <A extends Concept> A findConceptWhere(Class<A> c, Object... params) {
  return findConceptWhere(db_mainConcepts(), c, params);
}

static <A extends Concept> A findConceptWhere(Concepts concepts, Class<A> c, Object... params) {
  ping();
  params = expandParams(c, params);
  
  // indexed
  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;
      }
    }
    
  // table scan
  for (A x : concepts.list(c)) if (checkConceptFields(x, params)) return x;
  return null;
}

static Concept findConceptWhere(Concepts concepts, String c, Object... params) {
  for (Concept x : concepts.list(c)) if (checkConceptFields(x, params)) return x;
  return null;
}



// accept purpose argument so we are a drop-in for tempVerboseLock
static AutoCloseable tempLock(Lock lock) { return tempLock("", lock); }
static 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 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 void warnIfOddCount(Object... list) {
  if (odd(l(list)))
    printStackTrace("Odd list size: " + list);
}




// legacy mode





//sbool ping_actions_shareable = true;
static volatile boolean ping_pauseAll = false;
static int ping_sleep = 100; // poll pauseAll flag every 100
static volatile boolean ping_anyActions = false;
static Map<Thread, Object> ping_actions = newWeakHashMap();
static ThreadLocal<Boolean> ping_isCleanUpThread = new ThreadLocal();

// ignore pingSource if not PingV3
static boolean ping(PingSource pingSource) { return ping(); }

// always returns true
static boolean ping() {
  //ifdef useNewPing
  newPing();
  //endifdef
  if (ping_pauseAll || ping_anyActions) ping_impl(true /* XXX */);
  //ifndef LeanMode ping_impl(); endifndef
  return true;
}

// returns true when it slept
static boolean ping_impl(boolean okInCleanUp) { try {
  if (ping_pauseAll && !isAWTThread()) {
    do
      Thread.sleep(ping_sleep);
    while (ping_pauseAll);
    return true;
  }
  
  if (ping_anyActions) { // don't allow sharing ping_actions
    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 <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));
}

// TODO: sort by ID?
static <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 <A extends Concept> List<A> findBackRefs(Class<A> type, Concept c) {
  return findBackRefs(c, type);
}

static Collection<Concept> findBackRefs(Concept c) {
  return findBackRefs(c, Concept.class);
}



static 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 Object nuObject(String className, Object... args) { try {
  return nuObject(classForName(className), args);
} catch (Exception __e) { throw rethrow(__e); } }

// too ambiguous - maybe need to fix some callers
/*static O nuObject(O realm, S className, O... args) {
  ret nuObject(_getClass(realm, className), args);
}*/

static <A> A nuObject(Class<A> c, Object... args) { try {
  if (args == null || args.length == 0) return nuObjectWithoutArguments(c); // cached!
  
  Constructor m = nuObject_findConstructor(c, args);
  makeAccessible(m);
  return (A) m.newInstance(args);
} catch (Exception __e) { throw rethrow(__e); } }

static 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 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 HashMap<String, Class> findClass_cache = new HashMap();

// currently finds only inner classes of class "main"
// returns null on not found
// this is the simple version that is not case-tolerant
static 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;
  }
}


// returns number of changes
static int cset(Concept c, Object... values) { try {
  if (c == null) return 0;
  warnIfOddCount(values = expandParams(c.getClass(), values));
  int changes = 0;
  for (int i = 0; i+1 < l(values); i += 2)
    if (_csetField(c, (String) values[i], values[i+1])) ++changes;
  return changes;
} catch (Exception __e) { throw rethrow(__e); } }

static int cset(Iterable<? extends Concept> l, Object... values) {
  int changes = 0;
  for (Concept c : unnullForIteration(l))
    changes += cset(c, values);
  return changes;
}

static <A extends Concept> int cset(Concept.Ref<A> c, Object... values) {
  return cset(getVar(c), values);
}


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

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

static <A> List<A> unnullForIteration(List<A> l) { return l == null ? immutableEmptyList() : l; }
static byte[] unnullForIteration(byte[] l) { return l == null ? emptyByteArray() : l; }
static int[] unnullForIteration(int[] l) { return l == null ? emptyIntArray() : l; }
static char[] unnullForIteration(char[] l) { return l == null ? emptyCharArray() : l; }
static double[] unnullForIteration(double[] l) { return l == null ? emptyDoubleArray() : l; }
static short[] unnullForIteration(short[] l) { return l == null ? emptyShortArray() : l; }

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

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

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

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


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


//ifclass Symbol

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



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


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


static void clearTabs(final JTabbedPane tabs) {
  if (tabs != null) { swing(() -> {  tabs.removeAll(); }); }
}


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


// get purpose 1: access a list/array/map (safer version of x.get(y))

static <A> A get(List<A> l, int idx) {
  return l != null && idx >= 0 && idx < l(l) ? l.get(idx) : null;
}

// seems to conflict with other signatures
/*static <A, B> B get(Map<A, B> map, A key) {
  ret map != null ? map.get(key) : null;
}*/

static <A> A get(A[] l, int idx) {
  return idx >= 0 && idx < l(l) ? l[idx] : null;
}

// default to false
static boolean get(boolean[] l, int idx) {
  return idx >= 0 && idx < l(l) ? l[idx] : false;
}

// get purpose 2: access a field by reflection or a map

static Object get(Object o, String field) {
  try {
    if (o == null) return null;
    if (o instanceof Class) return get((Class) o, field);
    
    if (o instanceof Map)
      return ((Map) o).get(field);
      
    Field f = getOpt_findField(o.getClass(), field);
    if (f != null) {
      makeAccessible(f);
      return f.get(o);
    }
      
    
      if (o instanceof DynamicObject)
        return getOptDynOnly(((DynamicObject) o), field);
    
  } catch (Exception e) {
    throw asRuntimeException(e);
  }
  throw new RuntimeException("Field '" + field + "' not found in " + o.getClass().getName());
}

static Object get_raw(String field, Object o) {
  return get_raw(o, field);
}

static Object get_raw(Object o, String field) { try {
  if (o == null) return null;
  Field f = get_findField(o.getClass(), field);
  makeAccessible(f);
  return f.get(o);
} catch (Exception __e) { throw rethrow(__e); } }

static Object get(Class c, String field) {
  try {
    Field f = get_findStaticField(c, field);
    makeAccessible(f);
    return f.get(null);
  } catch (Exception e) {
    throw new RuntimeException(e);
  }
}

static Field get_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 Field get_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 Object get(String field, Object o) {
  return get(o, field);
}

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


static int asInt(Object o) {
  return toInt(o);
}


static String[] dropFirst(int n, String[] a) {
  return drop(n, a);
}

static String[] dropFirst(String[] a) {
  return drop(1, a);
}

static Object[] dropFirst(Object[] a) {
  return drop(1, a);
}

static <A> List<A> dropFirst(List<A> l) {
  return dropFirst(1, l);
}

static <A> List<A> dropFirst(int n, Iterable<A> i) { return dropFirst(n, toList(i)); }
static <A> List<A> dropFirst(Iterable<A> i) { return dropFirst(toList(i)); }

static <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 <A> List<A> dropFirst(List<A> l, int n) {
  return dropFirst(n, l);
}

static String dropFirst(int n, String s) { return substring(s, n); }
static String dropFirst(String s, int n) { return substring(s, n); }
static String dropFirst(String s) { return substring(s, 1); }


static <A> Chain<A> dropFirst(Chain<A> c) {
  return c == null ? null : c.next;
}



static Object[] arrayrep(Object a, int n) {
  Object[] array = new Object[n];
  for (int i = 0; i < n; i++) array[i] = a;
  return array;
}

static <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 boolean isComponentOrSwingable(Object o) {
  
    if (o instanceof Swingable) return true;
  
  return o instanceof Component;
}




static void addTab(JTabbedPane tabs, String title) { addTab(tabs, title, jpanel()); }
static void addTab(JTabbedPane tabs, String title, Component c) {
  if (tabs != null) { swing(() -> { 
    tabs.add(title, wrap(c));
  }); }
}

static void addTab(JTabbedPane tabs, String title, Swingable c) {
  if (tabs != null) { swing(() -> { 
    tabs.add(title, wrap(c));
  }); }
}


  static void addTab(JTabbedPane tabs, WithToolTip<String> title, Component c) {
    addTabWithToolTip(tabs, title.toolTip(), title == null ? null : title.get(), c);
  }


  static void addTab(JTabbedPane tabs, WithToolTip<String> title, Swingable c) {
    addTabWithToolTip(tabs, title.toolTip(), title == null ? null : title.get(), c);
  }




// c = Component or something implementing swing()
static JComponent wrap(Object swingable) {
  return _recordNewSwingComponent(wrap_2(swingable));
}

static 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 String str(Object o) {
  return o == null ? "null" : o.toString();
}

static String str(char[] c) {
  return c == null ? "null" : new String(c);
}

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


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


static 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 void addTabWithToolTip(JTabbedPane tabs, String title, String toolTip, Swingable c) {
  addTabWithToolTip(tabs, title, toolTip, wrap(c));
}


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

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

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

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

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

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

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

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

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

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


static <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 List _registerWeakMap_preList;

static <A> A _registerWeakMap(A map) {
  if (javax() == null) {
    // We're in class init
    if (_registerWeakMap_preList == null) _registerWeakMap_preList = synchroList();
    _registerWeakMap_preList.add(map);
    return map;
  }
  
  try {
    call(javax(), "_registerWeakMap", map);
  } catch (Throwable e) {
    printException(e);
    print("Upgrade JavaX!!");
  }
  return map;
}

static void _onLoad_registerWeakMap() {
  assertNotNull(javax());
  if (_registerWeakMap_preList == null) return;
  for (Object o : _registerWeakMap_preList)
    _registerWeakMap(o);
  _registerWeakMap_preList = null;
}


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

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


static void swingAndWait(Runnable r) { try {
  if (isAWTThread())
    r.run();
  else {
    r = addThreadInfoToRunnable(r);
    executingSwingCode(r);
    EventQueue.invokeAndWait(r);
  }
} catch (Exception __e) { throw rethrow(__e); } }

static Object swingAndWait(Object f) {
  if (isAWTThread())
    return callF(f);
  else {
    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 Object pcallFunction(Object f, Object... args) {
  try { return callFunction(f, args); } catch (Throwable __e) { pcallFail(__e); }
  return null;
}


static void pcallFail(Throwable e) {
  pcallPolicyForThread().handlePcallFail(e);
}

static void pcallFail(String msg) {
  pcallFail(new Throwable(msg));
}


static JMenuItem jMenuItem(final String text) {
  return jmenuItem(text);
}

static JMenuItem jMenuItem(String text, Object r) {
  return jmenuItem(text, r);
}


static 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 String dropPrefix(String prefix, String s) {
  return s == null ? null : s.startsWith(prefix) ? s.substring(l(prefix)) : s;
}


static JMenuItem disableMenuItem(final JMenuItem mi) {
  if (mi != null) { swing(() -> {  mi.setEnabled(false); }); }
  return mi;
}


static ActionListener actionListenerInNewThread(final Object runnable) {
  return actionListenerInNewThread(runnable, null);
}

static 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 ActionListener actionListener(final Object runnable) {
  return actionListener(runnable, null);
}

static 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 JMenuItem directJMenuItem(Action a) {
  return new JMenuItem(a) {
    public Dimension getMaximumSize() {
      return new Dimension(super.getPreferredSize().width, super.getMaximumSize().height);
    }
  };
}

static JMenuItem directJMenuItem(String text, Object action) {
  return directJMenuItem(abstractAction(text, action));
}



static 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 <A extends Component> A revalidate(final A c) {
  if (c == null || !c.isShowing()) return c;
  { swing(() -> { 
    // magic combo to actually relayout and repaint
    c.revalidate();
    c.repaint();
  }); }
  return c;
}

static void revalidate(JFrame f) { revalidate((Component) f); }
static void revalidate(JInternalFrame f) { revalidate((Component) f); }


static String defaultThreadName_name;

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


static 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..."; }};

}


// runnable = Runnable or String (method name)
static Thread newThread(Object runnable) {
  return new BetterThread(_topLevelErrorHandling(toRunnable(runnable)));
}

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

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


static 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 Map<Thread, Boolean> _registerThread_threads;
static Object _onRegisterThread; // voidfunc(Thread)

static 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 void _registerThread() {
  _registerThread(Thread.currentThread());
}


static Object dm_callOS(String functionName, Object... args) {
  return call(dm_os(), functionName, args);
}


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 boolean endsWithLetterOrDigit(String s) {
  return s != null && s.length() > 0 && Character.isLetterOrDigit(s.charAt(s.length()-1));
}


static Object getOpt(Object o, String field) {
  return getOpt_cached(o, field);
}

static Object getOpt(String field, Object o) {
  return getOpt_cached(o, field);
}

static Object getOpt_raw(Object o, String field) { try {
  Field f = getOpt_findField(o.getClass(), field);
  if (f == null) return null;
  makeAccessible(f);
  return f.get(o);
} catch (Exception __e) { throw rethrow(__e); } }

// access of static fields is not yet optimized
static Object getOpt(Class c, String field) { try {
  if (c == null) return null;
  Field f = getOpt_findStaticField(c, field);
  if (f == null) return null;
  makeAccessible(f);
  return f.get(null);
} catch (Exception __e) { throw rethrow(__e); } }

static Field getOpt_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);
  return null;
}



static <A, B> Map<A, B> newDangerousWeakHashMap() {
  return _registerDangerousWeakMap(synchroMap(new WeakHashMap()));
}

// initFunction: voidfunc(Map) - is called initially, and after clearing the map
static <A, B> Map<A, B> newDangerousWeakHashMap(Object initFunction) {
  return _registerDangerousWeakMap(synchroMap(new WeakHashMap()), initFunction);
}


static 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 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 Field makeAccessible(Field f) {
  try {
    f.setAccessible(true);
  } catch (Throwable e) {
    // Note: The error reporting only works with Java VM option --illegal-access=deny
    
    vmBus_send("makeAccessible_error", e, f);
    
  }
  return f;
}

static Method makeAccessible(Method m) {
  try {
    m.setAccessible(true);
  } catch (Throwable e) {
    
    vmBus_send("makeAccessible_error", e, m);
    
  }
  return m;
}

static Constructor makeAccessible(Constructor c) {
  try {
    c.setAccessible(true);
  } catch (Throwable e) {
    
    vmBus_send("makeAccessible_error", e, c);
    
  }
  return c;
}


// PersistableThrowable doesn't hold GC-disturbing class references in backtrace
static volatile PersistableThrowable lastException_lastException;

static PersistableThrowable lastException() {
  return lastException_lastException;
}

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


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

static 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 String hideCredentials(Object o) {
  return hideCredentials(str(o));
}


static <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 <A> int indexOf(List<A> l, int startIndex, A a) {
  return indexOf(l, a, startIndex);
}

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

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

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

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

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

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

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

static <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 <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 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 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 List<String> dm_moduleIDs() {
  return dm_listModuleIDs();
}


static String dm_moduleLibID() {
  return programID() + "/" + shortClassName(dm_current_mandatory_generic());
}

static String dm_moduleLibID(Object mod) {
  if (mod == null) return null;
  mod = dm_getModule(mod);
  if (hasSuperclassShortNamed(mod, "DynModule"))
    return programID(mod) + "/" + shortClassName(mod);
  return null;
}


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


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

// varargs assignment fixer for a single string array argument
static Object call(Object o, String method, String[] arg) {
  return call(o, method, new Object[] {arg});
}

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


static WeakReference<Object> creator_class;

static Object creator() {
  return creator_class == null ? null : creator_class.get();
}


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

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

static <A> List<A> unnull(List<A> l) { return l == null ? emptyList() : l; }
static int[] unnull(int[] l) { return l == null ? emptyIntArray() : l; }
static char[] unnull(char[] l) { return l == null ? emptyCharArray() : l; }
static double[] unnull(double[] l) { return l == null ? emptyDoubleArray() : l; }
static float[] unnull(float[] l) { return l == null ? emptyFloatArray() : l; }

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

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

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

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


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


//ifclass Symbol

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



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


static int unnull(Integer i) { return i == null ? 0 : i; }
static long unnull(Long l) { return l == null ? 0L : l; }
static double unnull(Double l) { return l == null ? 0.0 : l; }


static <A> List<A> takeFirst(List<A> l, int n) {
  return l(l) <= n ? l : newSubListOrSame(l, 0, n);
}

static <A> List<A> takeFirst(int n, List<A> l) {
  return takeFirst(l, n);
}

static String takeFirst(int n, String s) { return substring(s, 0, n); }
static String takeFirst(String s, int n) { return substring(s, 0, n); }

static CharSequence takeFirst(int n, CharSequence s) { return subCharSequence(s, 0, n); }

static <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 <A> List<A> takeFirst(int n, Iterable<A> i) {
  if (i == null) return null;
  return i == null ? null : takeFirst(n, i.iterator());
}

static <A> List<A> takeFirst(int n, IterableIterator<A> i) {
  return takeFirst(n, (Iterator<A>) i);
}

static int[] takeFirst(int n, int[] a) { return takeFirstOfIntArray(n, a); }

static short[] takeFirst(int n, short[] a) { return takeFirstOfShortArray(n, a); }

static byte[] takeFirst(int n, byte[] a) { return takeFirstOfByteArray(n, a); }
static byte[] takeFirst(byte[] a, int n) { return takeFirstOfByteArray(n, a); }

static double[] takeFirst(int n, double[] a) { return takeFirstOfDoubleArray(n, a); }
static double[] takeFirst(double[] a, int n) { return takeFirstOfDoubleArray(n, a); }


// returns l(s) if not found
static 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 int smartIndexOf(String s, int i, char c) {
  return smartIndexOf(s, c, i);
}

static 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 int smartIndexOf(String s, String sub) {
  return smartIndexOf(s, sub, 0);
}

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

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

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

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


// Use like this: renderVars(+x, +y)
// Or like this: renderVars("bla", +x, +y)
static 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 boolean isString(Object o) {
  return o instanceof String;
}


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


static Object dm_getService(String serviceName) {
  return empty(serviceName) ? null : dm_getModule(vmBus_query(assertIdentifier(serviceName)));
}


static boolean isStringOrIntOrLong(Object o) {
  return o instanceof String || o instanceof Integer || o instanceof Long;
}


static Object dm_resolveModule(Object moduleOrStem) {
  return dm_callOS("resolveModule", moduleOrStem);
}


static Object callOpt(Object o) {
  return callF(o);
}

static Object callOpt(Object o, String method, Object... args) {
  return callOpt_withVarargs(o, method, args);
}


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

static 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);
    
    // TODO: (super-rare) case where method exists static and non-static
    // with different args
    
    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); } }

// no longer synchronizes! (see #1102990)
static _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 boolean isStaticMethod(Method m) {
  return methodIsStatic(m);
}


static 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);
  
  // TODO: optimize
  
  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 String formatArgumentClasses(Object[] args) {
  return joinWithComma(map(__34 -> getClassName(__34), args));
}


static 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 Set vm_generalIdentityHashSet(Object name) {
  synchronized(vm_generalMap()) {
    Set set =  (Set) (vm_generalMap_get(name));
    if (set == null)
      vm_generalMap_put(name, set = syncIdentityHashSet());
    return set;
  }
}



static Map vm_generalHashMap(Object name) {
  synchronized(vm_generalMap()) {
    Map m =  (Map) (vm_generalMap_get(name));
    if (m == null)
      vm_generalMap_put(name, m = syncHashMap());
    return m;
  }
}



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


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


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


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


static 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 int lCharSequence(CharSequence s) {
  return s == null ? 0 : s.length();
}


// TODO: JDK 17!! ?? No! Yes? Yes!!

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

static Object collectionMutex(Object o) {
  

  if (o instanceof List) return o;
  
  // TODO: actually use our own maps so we can get the mutex properly
  
  String c = className(o);
  
    
  
    
  
  return o;
}


static int compareIgnoreCase_jdk(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 ArrayList emptyList() {
  return new ArrayList();
  //ret Collections.emptyList();
}

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

// Try to match capacity
static ArrayList emptyList(Iterable l) {
  return l instanceof Collection ? emptyList(((Collection) l).size()) : emptyList();
}

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

// get correct type at once
static <A> ArrayList<A> emptyList(Class<A> c) {
  return new ArrayList();
}


static <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 String reverseString(String s) {
  return empty(s) ? s : new StringBuilder(s).reverse().toString();
}




static <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 void ensureDBNotRunning(String name) {
  if (hasBot(name)) {
    try {
      String framesBot = dropSuffix(".", name) + " Frames";
      print("Trying to activate frames of running DB: " + framesBot);
      if (isOK(sendOpt(framesBot, "activate frames")) && isMainProgram())
        cleanKill();
    } catch (Throwable __e) { pcallFail(__e); }
    throw fail("Already running: " + name);
  }
}

static void ensureDBNotRunning() {
  ensureDBNotRunning(dbBotStandardName());
}


static String dbBotStandardName() {
  String home = userHome();
  String name = dbBotName(getDBProgramID());
  if (neq(home, actualUserHome()))
    name += " " + quote(home);
  return name + ".";
}


static <A extends Throwable> A printStackTrace(A e) {
  // we go to system.out now - system.err is nonsense
  if (e != null) print(getStackTrace(e));
  return e;
}

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

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

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


static volatile Android3 dbBot_instance;

static Android3 dbBot() { return dbBot(true); }
static Android3 dbBot(boolean ensureNotRunning) {
  return dbBot(dbBotStandardName(), ensureNotRunning);
}

static Android3 dbBot(String name) { return dbBot(name, true); }
static Android3 dbBot(String name, boolean ensureNotRunning) {
  if (ensureNotRunning)
    ensureDBNotRunning(name);
  return dbBot_instance = methodsBot2(name, assertNotNull(db_mainConcepts()), db_standardExposedMethods(), db_mainConcepts().lock);
}


static void thinAProgramsBackups(String progID, boolean doIt) {
  File dir = programDir(progID);
  thinAProgramsBackups(dir, doIt);
}

static void thinAProgramsBackups(File dir, boolean doIt) {
  List<File> files = new ArrayList();
  Map<File, Double> ageMap = new HashMap();
  
  // minutes (last group) are optional
  java.util.regex.Pattern pat = regexp("^(.*)\\.backup(20\\d\\d)(\\d\\d)(\\d\\d)-(\\d\\d)(\\d*)$");
  print("Processing backups in " + dir);
  
  for (File f : listFilesNotDirs(dir, newFile(dir, "backups"))) {
    String s = f.getName();
    java.util.regex.Matcher matcher = pat.matcher(s);
    { if (!(matcher.find())) continue; }
    String originalName = matcher.group(1);
    { if (!(eq(originalName, "concepts.structure.gz"))) continue; }
    //print("Found backup: " + sfu(matcherGroups(matcher)));
    int year = matcherInt(matcher, 2);
    int month = matcherInt(matcher, 3);
    int day = matcherInt(matcher, 4);
    int hour = matcherInt(matcher, 5);
    int minute = matcherInt(matcher, 6);
    long time = timestampFromYMDHM(year, month, day, hour, minute);
    double age = ((now()-time)/1000.0/60/60/24);
    //print("Age: " + age + " days");
    ageMap.put(f, age);
    files.add(f);
  }
  
  int numDeleted = 0;
  sortByMap_inPlace(files, ageMap);
  double lastAge = -1;
  for (File f : files) {
    double age = ageMap.get(f);
    if (!thinAProgramsBackups_shouldKeep(age, lastAge)) {
      //print("Deleting: " + f);
      ++numDeleted;
      if (doIt) {
        print("Deleting: " + f);
        f.delete();
      }
    } else {
      //print("Keeping: " + f);
      lastAge = age;
    }
  }
  if (numDeleted != 0)
    print((doIt ? "Deleted: " : "Would delete: ") + n(numDeleted, "file"));
}

// age = age in days
static boolean thinAProgramsBackups_shouldKeep(double age, double lastAge) {
  return defaultAgeBasedBackupRetentionStrategy_shouldKeep(age, lastAge);
}


static <A> int iteratorCount_int_close(Iterator<A> i) { try {
  int n = 0;
  if (i != null) while (i.hasNext()) { i.next(); ++n; }
  if (i instanceof AutoCloseable) ((AutoCloseable) i).close();
  return n;
} catch (Exception __e) { throw rethrow(__e); } }


static <A extends Concept> ConceptFieldIndexCI<A> getConceptFieldCIIndex(Class<A> c, String field) {
  return getConceptFieldCIIndex(db_mainConcepts(), c, field);
}

static <A extends Concept> ConceptFieldIndexCI<A> getConceptFieldCIIndex(Concepts concepts, Class<A> c, String field) {
  return (ConceptFieldIndexCI) concepts.getCIFieldIndex(c, field);
}


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


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

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


static Object _defaultClassFinder_value = defaultDefaultClassFinder();

static Object _defaultClassFinder() {
  return _defaultClassFinder_value;
}


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

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


static <A> A assertNotNull(Scorer scorer, String msg, A a) {
  if (scorer == null) return assertNotNull(msg, a);
  if (a == null) {
    print("BAD - " + msg + " is null: " + a);
    scorer.add(false);
  } else {
    print("OK, " + msg + " not null: " + a);
    scorer.add(true);
  }
  return a;
}



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


static 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 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);
  }
  // NO call to ping here! Make sure lock is always released.
} catch (Exception __e) { throw rethrow(__e); } }

static void lock(Lock lock, String msg) {
  print("Locking: " + msg);
  lock(lock);
}

static void lock(Lock lock, String msg, long timeout) {
  print("Locking: " + msg);
  lockOrFail(lock, timeout);
}

static ReentrantLock lock() {
  return fairLock();
}


static void unlock(Lock lock, String msg) {
  if (lock == null) return;
  lock.unlock();
  vmBus_send("unlocked", lock, "thread" , currentThread());
  print("Unlocked: " + msg); // print afterwards to make sure the lock is always unlocked
}

static void unlock(Lock lock) {
  if (lock == null) return;
  lock.unlock();
  vmBus_send("unlocked", lock, "thread" , currentThread());
}


// This is for main classes that are all static.
// (We don't go to base classes.)
static Set<String> listFields(Object c) {
  TreeSet<String> fields = new TreeSet();
  for (Field f : _getClass(c).getDeclaredFields())
    fields.add(f.getName());
  return fields;
}


static String n(long l, String name) {
  return l + " " + trim(l == 1 ? singular(name) : getPlural(name));
}

static String n(Collection l, String name) {
  return n(l(l), name);
}

static String n(Map m, String name) {
  return n(l(m), name);
}

static String n(Object[] a, String name) {
  return n(l(a), name);
}


  static String n(MultiSet ms, String name) {
    return n(l(ms), name);
  }



static boolean odd(int i) {
  return (i & 1) != 0;
}

static boolean odd(long i) {
  return (i & 1) != 0;
}

static boolean odd(BigInteger i) { return odd(toInt(i)); }


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


// TODO: test if android complains about this
static boolean isAWTThread() {
  if (isAndroid()) return false;
  if (isHeadless()) return false;
  return isAWTThread_awt();
}

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


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


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


// not a very good one
static boolean instanceOf(Object o, String className) {
  if (o == null) return false;
  String c = o.getClass().getName();
  return eq(c, className) || eq(c, "main$" + className);
}

// better
static boolean instanceOf(Object o, Class c) {
  if (c == null) return false;
  return c.isInstance(o);
}

static boolean instanceOf(Class c, Object o) {
  return instanceOf(o, c);
}


static <A, B> Set<A> keys(Map<A, B> map) {
  return map == null ? new HashSet() : map.keySet();
}

// convenience shortcut for keys_gen
static Set keys(Object map) {
  return keys((Map) map);
}


  static <A> Set<A> keys(MultiSet<A> ms) {
    return ms.keySet();
  }



  static <A, B> Set<A> keys(IMultiMap<A, B> mm) {
    return mm.keySet();
  }





static boolean eqicOrEq(Object a, Object b) {
  return a instanceof String && b instanceof String ? eqic((String) a, (String) b) : eq(a, b);
}


static Object cget(Object c, String field) {
  c = derefRef(c);
  Object o = getOpt(c, field);
  return derefRef(o);
}

static Object cget(String field, Object c) {
  return cget(c, field);
}


static Object deref(Object o) {
  if (o instanceof IRef) return ((IRef) o).get();
  return o;
}



static Map<String, Class> classForName_cache = synchroHashMap();

static Class classForName(String name) { return classForName(name, null); }
static Class classForName(String name, Object classFinder) {
  // first clause is when we're in class init
  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 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 Map<Class, Constructor> nuObjectWithoutArguments_cache = newDangerousWeakHashMap();

static Object nuObjectWithoutArguments(String className) { try {
  return nuObjectWithoutArguments(classForName(className));
} catch (Exception __e) { throw rethrow(__e); } }

static <A> A nuObjectWithoutArguments(Class<A> c) { try {
  if (nuObjectWithoutArguments_cache == null)
    // in class init
    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 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());
}





// TODO: convert to regularly cleared normal map
static Map<Class, Constructor[]> getDeclaredConstructors_cached_cache = newDangerousWeakHashMap();

static 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 List<Class> getClasses(Object[] array) {
  List<Class> l = emptyList(l(array));
  for (Object o : array) l.add(_getClass(o));
  return l;
}


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


// returns true if change
static boolean _csetField(Concept c, String field, Object value) { try {
  Field f = setOpt_findField(c.getClass(), field);
  //print("cset: " + c.id + " " + field + " " + struct(value) + " " + f);
  if (value instanceof RC) value = c._concepts.getConcept((RC) value);
  value = deref(value);
  
  if (value instanceof String && l((String) value) >= concepts_internStringsLongerThan) value = intern((String) value);
  
  if (f == null) {
    // dynamic field (undeclared)
    
    assertIdentifier(field);
    Object oldVal = mapGet(c.fieldValues, field);
    
    if (value instanceof Concept) {
      if (oldVal instanceof Concept.Ref)
        // change existing reference
        return ((Concept.Ref) oldVal).set((Concept) value);
      else {
        // overwrite non-reference value if any,
        // create new reference
        dynamicObject_setRawFieldValue(c, field, c.new Ref((Concept) value));
        c.change(); return true;
      }
    } else {
      // value is not a concept
      
      // if it was a reference, cleanly delete it
      if (oldVal instanceof Concept.Ref) ((Concept.Ref) oldVal).unindexAndDrop();
    
      if (eq(oldVal, value)) return false;
      
      if (isConceptList(value) && nempty(((List) value))) {
        // TODO: clean-up etc
        dynamicObject_setRawFieldValue(c, field, c.new RefL(((List) value)));
        c.change(); return true;
      }
      
      if (value == null) {
        // delete field
        dynamicObject_dropRawField(c, field);
      } else {
        // update or create field
        if (!isPersistable(value))
          throw fail("Can't persist: " + c + "." + field + " = "+ value);

        dynamicObject_setRawFieldValue(c, field, value);
      }
      c.change(); return true;
    }
  } else if (isSubtypeOf(f.getType(), Concept.Ref.class)) {
    // Concept.Ref magic
    ((Concept.Ref) f.get(c)).set((Concept) derefRef(value));
    c.change(); return true;
  } else if (isSubtypeOf(f.getType(), Concept.RefL.class)) {
    // Concept.RefL magic
    ((Concept.RefL) f.get(c)).replaceWithList(lmap(__35 -> derefRef(__35), (List) value));
    c.change(); return true;
  } else {
    Object old = f.get(c);
    if (neq(value, old)) {
      boolean isTransient = isTransient(f);
      if (!isTransient && !isPersistable(value))
        throw fail("Can't persist: " + c + "." + field + " = "+ value);
      f.set(c, value);
      if (!isTransient) c.change(); 
      return true;
    }
  }
  return false;
} catch (Exception __e) { throw rethrow(__e); } }


static <A> A getVar(IF0<A> v) {
  return v == null ? null : v.get();
}

static <A> A getVar(Optional<A> v) {
  return v == null ? null : v.orElse(null);
}


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


static byte[] emptyByteArray_a = new byte[0];
static byte[] emptyByteArray() { return emptyByteArray_a; }


static int[] emptyIntArray_a = new int[0];
static int[] emptyIntArray() { return emptyIntArray_a; }


static char[] emptyCharArray = new char[0];
static char[] emptyCharArray() { return emptyCharArray; }


static double[] emptyDoubleArray = new double[0];
static double[] emptyDoubleArray() { return emptyDoubleArray; }


static short[] emptyShortArray = new short[0];
static short[] emptyShortArray() { return emptyShortArray; }


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


static Object[] emptyObjectArray_a = new Object[0];
static Object[] emptyObjectArray() { return emptyObjectArray_a; }


static Symbol emptySymbol_value;

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


static Object[] asObjectArray(Collection l) {
  return toObjectArray(l);
}


static Field getOpt_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);
  return null;
}


static Object getOptDynOnly(DynamicObject o, String field) {
  if (o == null || o.fieldValues == null) return null;
  return o.fieldValues.get(field);
}


static 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 int toInt(long l) {
  if (l != (int) l) throw fail("Too large for int: " + l);
  return (int) l;
}


static 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 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 <A> List<A> drop(Iterable<A> c, Object pred) {
  return antiFilter(c, pred);
}



static List drop(Object pred, Iterable c) {
  return antiFilter(pred, c);
}



static List drop(Object pred, Object[] c) {
  return antiFilter(pred, c);
}



static <A, B extends A> List<B> drop(Iterable<B> c, F1<A, Boolean> pred) {
  return antiFilter(c, pred);
}



static <A, B extends A> List<B> drop(F1<A, Boolean> pred, Iterable<B> c) {
  return antiFilter(pred, c);
}



static <A, B extends A> List<B> drop(Iterable<B> c, IF1<A, Boolean> pred) {
  return antiFilter(c, pred);
}



static <A, B extends A> List<B> drop(IF1<A, Boolean> pred, Iterable<B> c) {
  return antiFilter(pred, c);
}


static <A> ArrayList<A> toList(A[] a) { return asList(a); }
static ArrayList<Integer> toList(int[] a) { return asList(a); }
static ArrayList<Short> toList(short[] a) { return asList(a); }
static ArrayList<Long> toList(long[] a) { return asList(a); }
static ArrayList<Double> toList(double[] a) { return asList(a); }
static ArrayList<Float> toList(float[] a) { return asList(a); }
static <A> ArrayList<A> toList(Set<A> s) { return asList(s); }
static <A> ArrayList<A> toList(Iterable<A> s) { return asList(s); }


static <A> A[] newArray(Class<A> c, int n) {
  return typedArray(c, n);
}


static JPanel jpanel(LayoutManager layout, Object... components) { return jpanel(layout, asList(components)); }
static JPanel jpanel(LayoutManager layout, List components) {
  return smartAdd(jpanel(layout), components);
}

static JPanel jpanel(LayoutManager layout) {
  return swing(() -> new JPanel(layout));
}
static JPanel jpanel() {
  return swing(() -> new JPanel());
}


static <A extends Component> A _recordNewSwingComponent(A c) {
  if (c != null)
    callF((Object) vm_generalMap_get("newSwingComponentRegistry"), (Object) c);
  return c;
}


static 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 JScrollPane jscroll(Component c) { return swing(() -> { 
  return c instanceof JScrollPane ? ((JScrollPane) c) : new JScrollPane(c);
}); }


static JLabel jlabel(final String text) {
  return swingConstruct(BetterLabel.class, text);
}

static JLabel jlabel() {
  return jlabel(" ");
}




static int tabCount(JTabbedPane tabs) {
  return tabs == null ? 0 : swing(() -> tabs.getTabCount());
}


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

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

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

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

static 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 Class javax() {
  return getJavaX();
}


static <A> List<A> synchroList() {
  return synchroList(new ArrayList<A>());
}

static <A> List<A> synchroList(List<A> l) {
  
  
    return Collections.synchronizedList(l);
  
}



static <A extends Throwable> A printException(A e) {
  printStackTrace(e);
  return e;
}


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



static 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 event executingSwingCode(Runnable code);

static transient Set<IVF1<Runnable>> onExecutingSwingCode;
public static void onExecutingSwingCode(IVF1<Runnable> f) { onExecutingSwingCode = createOrAddToSyncLinkedHashSet(onExecutingSwingCode, f); }
public static void removeExecutingSwingCodeListener(IVF1<Runnable> f) { main.remove(onExecutingSwingCode, f); }
public static void executingSwingCode(Runnable code) {  if (onExecutingSwingCode != null) for (var listener : onExecutingSwingCode) pcallF_typed(listener, code); }


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


static PCallPolicy pcallPolicyForThread() {
  var policy = pcallPolicyForThread_tl().get();
  if (policy != null) return policy;
  return defaultPCallPolicy();
}


static boolean isLetterOrDigit(char c) {
  return Character.isLetterOrDigit(c);
}


static ThreadLocal<List<Object>> holdInstance_l = new ThreadLocal();

static AutoCloseable holdInstance(Object o) {
  if (o == null) return null;
  listThreadLocalAdd(holdInstance_l, o);
  return new AutoCloseable() {
    public void close() {
      listThreadLocalPopLast(holdInstance_l);
    }
  };
}


static void messageBox(final String msg) {
  print(msg);
  { swing(() -> { 
    JOptionPane.showMessageDialog(null, msg, "JavaX", JOptionPane.INFORMATION_MESSAGE);
  }); }
}

static void messageBox(Throwable e) {
  //showConsole();
  printStackTrace(e);
  messageBox(hideCredentials(innerException2(e)));
}


static List<VF1<Map>> _threadInfo_makers = synchroList();

static Object _threadInfo() {
  if (empty(_threadInfo_makers)) return null;
  HashMap map = new HashMap();
  pcallFAll(_threadInfo_makers, map);
  return map;
}


static List<VF1<Map>> _threadInheritInfo_retrievers = synchroList();

static void _threadInheritInfo(Object info) {
  if (info == null) return;
  pcallFAll(_threadInheritInfo_retrievers, (Map) info);
}


static AbstractAction abstractAction(String name, final Object runnable) {
  return new AbstractAction(name) {
    public void actionPerformed(ActionEvent evt) {
      pcallF(runnable);
    }
  };
}


static RootPaneContainer getPossiblyInternalFrame(Component c) {
  JInternalFrame f = getInternalFrame(c);
  if (f != null) return f;
  return optCast(RootPaneContainer.class, getWindow(c));
}


static void setMenuBar(final JMenuBar mb, final RootPaneContainer f) {
  { swing(() -> { 
    call(f, "setJMenuBar", mb);
    revalidate((Component) f);
  }); }
}

static void setMenuBar(RootPaneContainer f, JMenuBar mb) {
  setMenuBar(mb, f);
}


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

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


static Object dm_current_generic() {
  return getWeakRef(dm_current_generic_tl().get());
}


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


static Runnable _topLevelErrorHandling(Runnable r) {


  if (r == null) return null;
  
  // maybe we don't want this anymore. just dm_current_generic()
  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 Map vm_generalWeakSubMap(Object name) {
  synchronized(vm_generalMap()) {
    Map map =  (Map) (vm_generalMap_get(name));
    if (map == null)
      vm_generalMap_put(name, map = newWeakMap());
    return map;
  }
}



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


static Object dm_os() {
  { var __1= vm_generalMap_get("stefansOS"); if (__1 != null) return __1; }
  return creator();
}


//static final Map<Class, HashMap<S, Field>> getOpt_cache = newDangerousWeakHashMap(f getOpt_special_init);

static class getOpt_Map extends WeakHashMap {
  getOpt_Map() {
    if (getOpt_special == null) getOpt_special = new HashMap();
    clear();
  }
  
  public void clear() {
    super.clear();
    //print("getOpt clear");
    put(Class.class, getOpt_special);
    put(String.class, getOpt_special);
  }
}

static final Map<Class, HashMap<String, Field>> getOpt_cache = 
  
  
    _registerDangerousWeakMap(synchroMap(new getOpt_Map()));
  
  
static HashMap getOpt_special; // just a marker

/*static void getOpt_special_init(Map map) {
  map.put(Class.class, getOpt_special);
  map.put(S.class, getOpt_special);
}*/

static 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 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 S)
      ret getOpt(getBot((S) 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); } }

// used internally - we are in synchronized block
static 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 List<Pair> _registerDangerousWeakMap_preList;

static <A> A _registerDangerousWeakMap(A map) {
  return _registerDangerousWeakMap(map, null);
}

static <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) {
    // We're in class init
    if (_registerDangerousWeakMap_preList == null) _registerDangerousWeakMap_preList = synchroList();
    _registerDangerousWeakMap_preList.add(pair(map, init));
    return map;
  }
  
  call(javax(), "_registerDangerousWeakMap", map, init);
  
  return map;
}

static void _onLoad_registerDangerousWeakMap() {
  
  assertNotNull(javax());
  if (_registerDangerousWeakMap_preList == null) return;
  for (Pair p : _registerDangerousWeakMap_preList)
    _registerDangerousWeakMap(p.a, p.b);
  _registerDangerousWeakMap_preList = null;
  
}


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


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

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



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

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


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


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

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


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


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


static List<String> dm_listModuleIDs() {
  return map(__36 -> dm_moduleID(__36), dm_listStems());
}


static 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 Object dm_current_mandatory_generic() {
  return assertNotNull("No module set", dm_current_generic());
}


static boolean hasSuperclassShortNamed(Object o, String name) {
  Class c = _getClass(o);
  while (c != null)
    if (shortClassNameIs(c, name)) return true;
    else c = c.getSuperclass();
  return false;
}


static float[] emptyFloatArray = new float[0];
static float[] emptyFloatArray() { return emptyFloatArray; }


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


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

static <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 CharSequence subCharSequence(CharSequence s, int x) {
  return subCharSequence(s, x, s == null ? 0 : s.length());
}

static 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 int[] takeFirstOfIntArray(int[] b, int n) {
  return subIntArray(b, 0, n);
}

static int[] takeFirstOfIntArray(int n, int[] b) {
  return takeFirstOfIntArray(b, n);
}


static short[] takeFirstOfShortArray(short[] b, int n) {
  return subShortArray(b, 0, n);
}

static short[] takeFirstOfShortArray(int n, short[] b) {
  return takeFirstOfShortArray(b, n);
}


static byte[] takeFirstOfByteArray(byte[] b, int n) {
  return subByteArray(b, 0, n);
}

static byte[] takeFirstOfByteArray(int n, byte[] b) {
  return takeFirstOfByteArray(b, n);
}


static double[] takeFirstOfDoubleArray(double[] b, int n) {
  return subDoubleArray(b, 0, n);
}

static double[] takeFirstOfDoubleArray(int n, double[] b) {
  return takeFirstOfDoubleArray(b, n);
}


static String strOrNull(Object o) {
  return o == null ? null : str(o);
}


static String trim(String s) { return s == null ? null : s.trim(); }
static String trim(StringBuilder buf) { return buf.toString().trim(); }
static String trim(StringBuffer buf) { return buf.toString().trim(); }


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

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

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


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



static Object vmBus_query(String msg, Object... args) {
  Object arg = vmBus_wrapArgs(args);
  { var __1= pcallFAll_returnFirstNotNull(vm_busListeners_live(), msg, arg); if (__1 != null) return __1; }
  return pcallFAll_returnFirstNotNull(vm_busListenersByMessage_live().get(msg), msg, arg);
}

static Object vmBus_query(String msg) {
  return vmBus_query(msg, (Object) null);
}


static String assertIdentifier(String s) {
  return assertIsIdentifier(s);
}

static String assertIdentifier(String msg, String s) {
  return assertIsIdentifier(msg, s);
}


static Object callOpt_withVarargs(Object o, String method, 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(method, args);
    if (me == null) {
      // TODO: varargs
      return null;
    }
    if ((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(method, args);
    if (me != null)
      return invokeMethod(me, o, args);
      
    // try varargs
    List<Method> methods = cache.cache.get(method);
    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);
    }
    
    return null;
  }
} catch (Exception __e) { throw rethrow(__e); } }


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


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



static List map(Iterable l, Object f) { return map(f, l); }

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

// map: func(key, value) -> list element
static 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 List map(Object f, Object[] l) { return map(f, asList(l)); }
static List map(Object[] l, Object f) { return map(f, l); }

static List map(Object f, Map map) {
  return map(map, f);
}




  static <A, B> List<B> map(Iterable<A> l, F1<A, B> f) { return map(f, l); }

  static <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 <A, B> List<B> map(IF1<A, B> f, Iterable<A> l) { return map(l, f); }
static <A, B> List<B> map(Iterable<A> l, IF1<A, B> f) {
  List x = emptyList(l);
  if (l != null) {
    var it = l.iterator();
    if (it.hasNext()) {
      var pingSource = pingSource();
      do {
        ping(pingSource);
        x.add(f.get(it.next()));
      } while (it.hasNext());
    }
  }
  return x;
}
  
static <A, B> List<B> map(IF1<A, B> f, A[] l) { return map(l, f); }
static <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 <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;
}

// new magic alias for mapLL - does it conflict?

static <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 Throwable _storeException_value;

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


static Map vm_generalMap_map;

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


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


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


static <A> Set<A> syncIdentityHashSet() {
  return (Set) synchronizedSet(identityHashSet());
}


static Map syncHashMap() {
  return synchroHashMap();
}


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


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


static int max(int a, int b) { return Math.max(a, b); }
static int max(int a, int b, int c) { return max(max(a, b), c); }
static long max(int a, long b) { return Math.max((long) a, b); }
static long max(long a, long b) { return Math.max(a, b); }
static double max(int a, double b) { return Math.max((double) a, b); }
static float max(float a, float b) { return Math.max(a, b); }
static double max(double a, double b) { return Math.max(a, b); }

static <A extends Comparable<A>> A max (Iterable<A> l) {
  A max = null;
  var it = iterator(l);
  if (it.hasNext()) {
    max = it.next();
    while (it.hasNext()) {
      A a = it.next();
      if (cmp(a, max) > 0)
        max = a;
    }
  }
  return max;
}

/*Nah.
static int max(Collection<Integer> c) {
  int x = Integer.MIN_VALUE;
  for (int i : c) x = max(x, i);
  ret x;
}*/

static 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 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 byte max(byte[] c) {
  byte x = -128;
  for (byte d : c) if (d > x) x = d;
  return x;
}

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

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

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




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


static boolean hasBot(String searchPattern) { try {
  DialogIO io = findBot(searchPattern);
  if (io != null) {
    io.close();
    return true;
  } else
    return false;
} catch (Exception __e) { throw rethrow(__e); } }


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


static boolean isOK(String s) {
  s = trim(s);
  return swic(s, "ok ") || eqic(s, "ok") || matchStart("ok", s);
}


static String sendOpt(String bot, String text, Object... args) {
  return sendToLocalBotOpt(bot, text, args);
}


static boolean isMainProgram() {
  return creator() == null;
}


static void cleanKill() {
  cleanKillVM();
}


static String _userHome;
static String userHome() {
  if (_userHome == null)
    return actualUserHome();
  return _userHome;
}

static File userHome(String path) {
  return new File(userDir(), path);
}


static String dbBotName(String progIDWithCase) {
  return fsI_flex(progIDWithCase) + " Concepts";
}


static String actualUserHome_value;
static String actualUserHome() {
  if (actualUserHome_value == null) {
    if (isAndroid())
      actualUserHome_value = "/storage/emulated/0/";
    else
      actualUserHome_value = System.getProperty("user.home");
  }
  return actualUserHome_value;
}

static File actualUserHome(String sub) {
  return newFile(new File(actualUserHome()), sub);
}


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

static 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 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('"');
}


static Android3 methodsBot2(String name, final Object receiver, final List<String> exposedMethods) {
  return methodsBot2(name, receiver, exposedMethods, null);
}

static Android3 methodsBot2(String name, final Object receiver, final List<String> exposedMethods, final Lock lock) {
  Android3 android = new Android3();
  android.greeting = name;
  android.console = false;
  android.responder = new Responder() {
    public String answer(String s, List<String> history) {
      return exposeMethods2(receiver, s, exposedMethods, lock);
    }
  };
  return makeBot(android);
}


static List<String> db_standardExposedMethods_list = ll("xlist", "xnew", "xset", "xdelete", "xget", "xclass", "xfullgrab", "xshutdown", "xchangeCount", "xcount");

static List<String> db_standardExposedMethods() {
  return db_standardExposedMethods_list;
}


static File programDir_mine; // set this to relocate program's data

static File programDir() {
  return programDir(getProgramID());
}

static 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 File programDir(String snippetID, String subPath) {
  return new File(programDir(snippetID), subPath);
}


static Matcher regexp(String pat, String s) {
  return regexp(compileRegexp(pat), unnull(s));
}

static Matcher regexp(java.util.regex.Pattern pat, String s) {
  return pat.matcher(unnull(s));
}

static java.util.regex.Pattern regexp(String pat) {
  return compileRegexp(pat);
}


static List<File> listFilesNotDirs(String dir) {
  return listFilesOnly(dir);
}

static List<File> listFilesNotDirs(File... dirs) {
  return listFilesOnly(dirs);
}


static File newFile(File base, String... names) {
  for (String name : names) base = new File(base, name);
  return base;
}

static File newFile(String name) {
  return name == null ? null : new File(name);
}

static File newFile(String base, String... names) {
  return newFile(newFile(base), names);
}


static int matcherInt(Matcher m, int i) {
  return parseInt(m.group(i));
}


// month = 1 to 12
static long timestampFromYMDHM(int y, int m, int d, int h, int minutes) {
  return new GregorianCalendar(y, m-1, d, h, minutes).getTimeInMillis();
}


static long now_virtualTime;
static long now() {
  return now_virtualTime != 0 ? now_virtualTime : System.currentTimeMillis();
}



static <A> List<A> sortByMap_inPlace(List<A> l, Map<A, ?> map) {
  sort(l, mapComparator(map));
  return l;
}


// age = age in days, lastAge = age of last (more recent) file kept (also in days)
static boolean defaultAgeBasedBackupRetentionStrategy_shouldKeep(double age, double lastAge) {
  if (age <= 1/12.0) return true; // keep all backups within last hour
  if (age <= 0.5 && age >= lastAge+1/12.0) return true; // keep hourly backups within last 12 hours
  if (age <= 7 && age >= lastAge+1) return true; // keep every daily backup from this week
  if (age <= 28 && age >= lastAge+7) return true; // weekly backups for 3 more weeks
  if (age >= lastAge+365.0/12) return true; // after 4 weeks, switch to monthly (roundabout)
  return false;
}


static Object defaultDefaultClassFinder() {
  return new F1<String, Class>() {
    public Class get(String name) {
      // Fix some buggy concepts files out there
      name = replacePrefix("main$main$", "main$", name);
      
      Class c = get2(name);
      
        printVars_str("ddcf", "name", name, "c", c);
      
      return c;
    }
      
    Class get2(String name) {
      // special invocation to find main class irrelevant of 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);
          
            print("ddcf looking for ", newName);
          
          { Class c = findClass_fullName(newName); if (c != null) return c; }
        }
      return null;
    }
  };
}


static void assertTrue(Object o) {
  if (!(eq(o, true) /*|| isTrue(pcallF(o))*/))
    throw fail(str(o));
}
  
static boolean assertTrue(String msg, boolean b) {
  if (!b)
    throw fail(msg);
  return b;
}

static boolean assertTrue(boolean b) {
  if (!b)
    throw fail("oops");
  return b;
}

static boolean assertTrue(Scorer scorer, boolean b) {
  scorer.add(b);
  return b;
}


static volatile String caseID_caseID;

static String caseID() { return caseID_caseID; }

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


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


static Map<Thread, Object> vm_threadInterruptionReasonsMap() {
  return vm_generalWeakSubMap("Thread interruption reasons");
}


static String strOr(Object o, String ifNull) {
  return o == null ? ifNull : str(o);
}


static 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 ReentrantLock fairLock() {
  return new ReentrantLock(true);
}


static Class<?> _getClass(String name) {
  try {
    return Class.forName(name);
  } catch (ClassNotFoundException e) {
    return null; // could optimize this
  }
}

static Class _getClass(Object o) {
  return o == null ? null
    : o instanceof Class ? (Class) o : o.getClass();
}

static Class _getClass(Object realm, String name) {
  try {
    return classLoaderForObject(realm).loadClass(classNameToVM(name));
  } catch (ClassNotFoundException e) {
    return null; // could optimize this
  }
}


static Map<String, String> singular_specials = litmap(
  "children", "child", "images", "image", "chess", "chess");
  
static Set<String> singular_specials2 = litciset("time", "machine", "line", "rule");

static String singular(String s) {
  if (s == null) return null;
  { String __1 = singular_specials.get(s); if (!empty(__1)) return __1; }
  //try answer hippoSingulars().get(lower(s));
  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 Set<String> getPlural_specials = litciset("sheep", "fish");

static 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 x30_pkg.x30_util.BetterThreadLocal<Runnable> newPing_actionTL;

static 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 int isAndroid_flag;

static boolean isAndroid() {
  if (isAndroid_flag == 0)
    isAndroid_flag = System.getProperty("java.vendor").toLowerCase().indexOf("android") >= 0 ? 1 : -1;
  return isAndroid_flag > 0;
}



static Boolean isHeadless_cache;

static boolean isHeadless() {
  if (isHeadless_cache != null) return isHeadless_cache;
  if (isAndroid()) return isHeadless_cache = true;
  if (GraphicsEnvironment.isHeadless()) return isHeadless_cache = true;
  
  // Also check if AWT actually works.
  // If DISPLAY variable is set but no X server up, this will notice.
  
  try {
    SwingUtilities.isEventDispatchThread();
    return isHeadless_cache = false;
  } catch (Throwable e) { return isHeadless_cache = true; }
}


static volatile boolean licensed_yes = true;

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

static void licensed_off() {
  licensed_yes = false;
}


static Object derefRef(Object o) {
  if (o instanceof Concept.Ref) o = ((Concept.Ref) o).get();
  return o;
}

static <A extends Concept> A derefRef(Concept.Ref<A> r) {
  return r == null ? null : r.get();
}


static Field setOpt_findField(Class c, String field) {
  HashMap<String, Field> map;
  synchronized(getOpt_cache) {
    map = getOpt_cache.get(c);
    if (map == null)
      map = getOpt_makeCache(c);
  }
  return map.get(field);
}

static void setOpt(Object o, String field, Object value) { try {
  if (o == null) return;
  
  
  
  Class c = o.getClass();
  HashMap<String, Field> map;
  
  if (getOpt_cache == null)
    map = getOpt_makeCache(c); // in class init
  else synchronized(getOpt_cache) {
    map = getOpt_cache.get(c);
    if (map == null)
      map = getOpt_makeCache(c);
  }
  
  if (map == getOpt_special) {
    if (o instanceof Class) {
      setOpt((Class) o, field, value);
      return;
    }
    
    // It's probably a subclass of Map. Use raw method. TODO: huh?
    setOpt_raw(o, field, value);
    return;
  }
  
  Field f = map.get(field);
  
  if (f != null)
    { smartSet(f, o, value); return; } // possible improvement: skip setAccessible
  
    if (o instanceof DynamicObject)
      { setDyn(((DynamicObject) o), field, value); return; }
  
  if (o instanceof IMeta)
    setDyn(((IMeta) o), field, value);
} catch (Exception __e) { throw rethrow(__e); } }

static void setOpt(Class c, String field, Object value) {
  if (c == null) return;
  try {
    Field f = setOpt_findStaticField(c, field); // TODO: optimize
    if (f != null)
      smartSet(f, null, value);
  } catch (Exception e) {
    throw new RuntimeException(e);
  }
}
  
static Field setOpt_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) {
        makeAccessible(f);
        return f;
      }
    _c = _c.getSuperclass();
  } while (_c != null);
  return null;
}


static String intern(String s) {
  return fastIntern(s);
}


static void dynamicObject_setRawFieldValue(DynamicObject o, Object key, Object value) {
  if (o == null) return;
  
  // double sync, but should be OK here because of locking order o > o.fieldValues
  synchronized(o) {
    o.fieldValues = syncMapPut2_createLinkedHashMap((LinkedHashMap) o.fieldValues, key, value);
  }
}


static boolean isConceptList(Object o) {
  if (!(o instanceof List)) return false;
  List l =  (List) o;
  for (Object x : l) if (!(x instanceof Concept)) return false;
  return true;
}


static void dynamicObject_dropRawField(DynamicObject o, Object key) {
  if (o == null) return;
  
  // double sync, but should be OK here because of locking order o > o.fieldValues
  synchronized(o) {
    // can drop the inner synchronization when we migrated all users
    // of fieldValues to synchronizing on the object too
    o.fieldValues = (LinkedHashMap) syncMapRemove_deleteMapIfEmpty((Map) o.fieldValues, key);
  }
}


static boolean isPersistable(Object o) {
  return !isInAnonymousClass(o);
}


static boolean isSubtypeOf(Class a, Class b) {
  return a != null && b != null && b.isAssignableFrom(a); // << always hated that method, let's replace it!
}


static <A, B> List<B> lmap(IF1<A, B> f, Iterable<A> l) {
  return lambdaMap(f, l);
}



static <A, B> List<B> lmap(IF1<A, B> f, A[] l) {
  return lambdaMap(f, l);
}


static boolean isTransient(Field f) {
  return (f.getModifiers() & java.lang.reflect.Modifier.TRANSIENT) != 0;
}




static 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 Symbol symbol(String s) {
  
  
  if (s == null) return null;
  synchronized(symbol_map) {
    // TODO: avoid object creation by passing the string to findKey
    Symbol symbol = new Symbol(s, true);
    Symbol existingSymbol = symbol_map.findKey(symbol);
    if (existingSymbol == null)
      symbol_map.put(existingSymbol = symbol, true);
    
      
    return existingSymbol;
  }
  
}

static 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 Symbol symbol(Object o) {
  return symbol((CharSequence) o);
}


// binary legacy signature
static Object[] toObjectArray(Collection c) {
  return toObjectArray((Iterable) c);
}

static Object[] toObjectArray(Iterable c) {
  List l = asList(c);
  return l.toArray(new Object[l.size()]);
}



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

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


static int boolToInt(boolean b) {
  return b ? 1 : 0;
}


static <A> List<A> antiFilter(Iterable<A> c, Object pred) {
  if (pred instanceof F1) return antiFilter(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 List antiFilter(Object pred, Iterable c) {
  return antiFilter(c, pred);
}

static List antiFilter(Object pred, Object[] c) {
  return antiFilter(pred, wrapArrayAsList(c));
}

static <A, B extends A> List<B> antiFilter(Iterable<B> c, F1<A, Boolean> pred) {
  List x = new ArrayList();
  if (c != null) for (B o : c)
    if (!pred.get(o).booleanValue())
      x.add(o);
  return x;
}

static <A, B extends A> List<B> antiFilter(F1<A, Boolean> pred, Iterable<B> c) {
  return antiFilter(c, pred);
}

static <A, B extends A> List<B> antiFilter(Iterable<B> c, IF1<A, Boolean> pred) {
  List x = new ArrayList();
  if (c != null) for (B o : c)
    if (!pred.get(o).booleanValue())
      x.add(o);
  return x;
}

static <A, B extends A> List<B> antiFilter(IF1<A, Boolean> pred, Iterable<B> c) {
  return antiFilter(c, pred);
}



static <A> A[] typedArray(Class<A> c, int n) {
  return (A[]) Array.newInstance(c, n);
}


static JPanel smartAdd(JPanel panel, List parts) {
  for (Object o : parts)
    addToContainer(panel, wrapForSmartAdd(o));
  return panel;
}

static JPanel smartAdd(JPanel panel, Object... parts) {
  return smartAdd(panel, asList(parts));
}



static Class __javax;

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

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


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

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


static Runnable asRunnable(Object o) {
  return toRunnable(o);
}




static void _inheritThreadInfo(Object info) {
  _threadInheritInfo(info);
}


static <A> Set<A> createOrAddToSyncLinkedHashSet(Set<A> set, A a) {
  if (set == null) set = syncLinkedHashSet();
  set.add(a);
  return set;
}


static Class main() {
  return getMainClass();
}


static <A> void remove(List<A> l, int i) {
  if (l != null && i >= 0 && i < l(l))
    l.remove(i);
}

static <A> void remove(Collection<A> l, A a) {
  if (l != null) l.remove(a);
}

static <A, B> B remove(Map<A, B> map, Object a) {
  return map == null ? null : map.remove(a);
}

static void remove(BitSet bs, int i) {
  bs.clear(i);
}



static <A> A pcallF_typed(F0<A> f) {
  try { return f == null ? null : f.get(); } catch (Throwable __e) { pcallFail(__e); } return null;
}



static <A, B> B pcallF_typed(F1<A, B> f, A a) {
  try { return f == null ? null : f.get(a); } catch (Throwable __e) { pcallFail(__e); } return null;
}



static <A> void pcallF_typed(VF1<A> f, A a) {
  try {
    { if (f != null) f.get(a); }
  } catch (Throwable __e) { pcallFail(__e); }
}


static <A> void pcallF_typed(IVF1<A> f, A a) {
  try {
    { if (f != null) f.get(a); }
  } catch (Throwable __e) { pcallFail(__e); }
}

static <A, B> void pcallF_typed(IVF2<A, B> f, A a, B b) {
  try {
    { if (f != null) f.get(a, b); }
  } catch (Throwable __e) { pcallFail(__e); }
}

static Object pcallF_typed(Runnable r) {
  try { { if (r != null) r.run(); } } catch (Throwable __e) { pcallFail(__e); } return null;
}

static <A> A pcallF_typed(IF0<A> f) {
  try { return f == null ? null : f.get(); } catch (Throwable __e) { pcallFail(__e); } return null;
}

static <A, B> B pcallF_typed(IF1<A, B> f, A a) {
  try { return f == null ? null : f.get(a); } catch (Throwable __e) { pcallFail(__e); } return null;
}





static ThreadLocal<PCallPolicy> pcallPolicyForThread_tl_tl = new ThreadLocal();

static ThreadLocal<PCallPolicy> pcallPolicyForThread_tl() {
  return pcallPolicyForThread_tl_tl;
}


static PCallPolicy defaultPCallPolicy = __1 -> printStackTrace(__1);

static PCallPolicy defaultPCallPolicy() {
  return defaultPCallPolicy;
}

static void defaultPCallPolicy_set(PCallPolicy policy) {
  defaultPCallPolicy = policy;
}


static <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 <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 Throwable innerException2(Throwable e) {
  if (e == null) return null;
  while (empty(e.getMessage()) && e.getCause() != null)
    e = e.getCause();
  return e;
}


static void pcallFAll(Collection l, Object... args) {
  if (l != null) for (Object f : cloneList(l)) pcallF(f, args);
}

static void pcallFAll(Iterator it, Object... args) {
  while (it.hasNext()) pcallF(it.next(), args);
}


static 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 <A> A optCast(Class<A> c, Object o) {
  return isInstance(c, o) ? (A) o : null;
}


static 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 String programID;
static String getProgramID() {
  return nempty(programID) ? formatSnippetIDOpt(programID) : "?";
}


// TODO: ask JavaX instead
static String getProgramID(Class c) {
  String id = (String) getOpt(c, "programID");
  if (nempty(id))
    return formatSnippetID(id);
  return "?";
}


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


static <A> A getWeakRef(Reference<A> ref) {
  return ref == null ? null : ref.get();
}


static x30_pkg.x30_util.BetterThreadLocal<WeakReference> dm_current_generic_tl;

static x30_pkg.x30_util.BetterThreadLocal<WeakReference> dm_current_generic_tl() {
  if (dm_current_generic_tl == null)
    dm_current_generic_tl = vm_generalMap_getOrCreate("currentModule", () -> new x30_pkg.x30_util.BetterThreadLocal());
  return dm_current_generic_tl;
}


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


static <A, B> Map<A, B> newWeakMap() {
  return newWeakHashMap();
}


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


static void clear(Collection c) {
  if (c != null) c.clear();
}

static void clear(Map map) {
  if (map != null) map.clear();
}


static <A, B> void put(Map<A, B> map, A a, B b) {
  if (map != null) map.put(a, b);
}

static <A> void put(List<A> l, int i, A a) {
  if (l != null && i >= 0 && i < l(l)) l.set(i, a);
}


static <A, B> B syncMapGet2(Map<A, B> map, A a) {
  if (map == null) return null;
  synchronized(collectionMutex(map)) {
    return map.get(a);
  }
}

static <A, B> B syncMapGet2(A a, Map<A, B> map) {
  return syncMapGet2(map, a);
}


static Set<String> reflection_classesNotToScan_value = litset(
  "jdk.internal.loader.URLClassPath"
);

static Set<String> reflection_classesNotToScan() {
  return reflection_classesNotToScan_value;
}


static HashMap<String, List<Method>> callMC_cache = new HashMap();
static String callMC_key;
static Method callMC_value;

// varargs assignment fixer for a single string array argument
static Object callMC(String method, String[] arg) {
  return callMC(method, new Object[] {arg});
}

static Object callMC(String method, Object... args) { try {
  Method me;
  if (callMC_cache == null) callMC_cache = new HashMap(); // initializer time workaround
  synchronized(callMC_cache) {
    me = method == callMC_key ? callMC_value : null;
  }
  if (me != null) try {
    return invokeMethod(me, null, args);
  } catch (IllegalArgumentException e) {
    throw new RuntimeException("Can't call " + me + " with arguments " + classNames(args), e);
  }

  List<Method> m;
  synchronized(callMC_cache) {
    m = callMC_cache.get(method);
  }
  if (m == null) {
    if (callMC_cache.isEmpty()) {
      callMC_makeCache();
      m = callMC_cache.get(method);
    }
    if (m == null) throw fail("Method named " + method + " not found in main");
  }
  int n = m.size();
  if (n == 1) {
    me = m.get(0);
    synchronized(callMC_cache) {
      callMC_key = method;
      callMC_value = me;
    }
    try {
      return invokeMethod(me, null, args);
    } catch (IllegalArgumentException e) {
      throw new RuntimeException("Can't call " + me + " with arguments " + classNames(args), e);
    }
  }
  for (int i = 0; i < n; i++) {
    me = m.get(i);
    if (call_checkArgs(me, args, false))
      return invokeMethod(me, null, args);
  }
  throw fail("No method called " + method + " with arguments (" + joinWithComma(getClasses(args)) + ") found in main");
} catch (Exception __e) { throw rethrow(__e); } }

static void callMC_makeCache() {
  synchronized(callMC_cache) {
    callMC_cache.clear();
    Class _c = (Class) mc(), c = _c;
    while (c != null) {
      for (Method m : c.getDeclaredMethods())
        if ((m.getModifiers() & java.lang.reflect.Modifier.STATIC) != 0) {
          makeAccessible(m);
          multiMapPut(callMC_cache, m.getName(), m);
        }
      c = c.getSuperclass();
    }
  }
}


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

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

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


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



static 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 String theAGIBlueDomain() {
  return "agi.blue";
}


static String dm_moduleID(Object module) {
  return strOrNull(getOpt(dm_getStem(module), "id"));
}

static String dm_moduleID() {
  return dm_moduleID(dm_current_mandatory_generic());
}


static List dm_listStems() {
  return (List) dm_callOS("onModules");
}


static 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 boolean shortClassNameIs(Object o, String name) {
  return eq(shortClassName(o), name);
}

static boolean shortClassNameIs(String name, Object o) {
  return shortClassNameIs(o, name);
}


static int[] subIntArray(int[] b, int start) {
  return subIntArray(b, start, l(b));
}
  
static 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 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 byte[] subByteArray(byte[] b, int start) {
  return subByteArray(b, start, l(b));
}
  
static 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 double[] subDoubleArray(double[] b, int start) { return subDoubleArray(b, start, l(b)); }
static 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 Object pcallFAll_returnFirstNotNull(Collection l, Object... args) {
  if (l != null) for (Object f : cloneList(l))
    { var __1= pcallF(f, args); if (__1 != null) return __1; }
  return null;
}

static Object pcallFAll_returnFirstNotNull(Iterator it, Object... args) {
  while (it.hasNext())
    { var __2= pcallF(it.next(), args); if (__2 != null) return __2; }
  return null;
}


static String assertIsIdentifier(String s) {
  if (!isIdentifier(s))
    throw fail("Not an identifier: " + quote(s));
  return s;
}

static String assertIsIdentifier(String msg, String s) {
  if (!isIdentifier(s))
    throw fail(msg + " - Not an identifier: " + quote(s));
  return s;
}


// assumptions:
// -pingSource() stays constant within a stack frame (so you can cache it)
// -all changes happen with tempSetPingSource
// -multiple threads can share a PingSource
static PingSource pingSource() {
  return pingSource_tl().get();
}

static PingSource pingSource(Thread thread) {
  return pingSource_tl().get(thread);
}


static <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 <A> Set<A> synchronizedSet() {
  return synchroHashSet();
}

static <A> Set<A> synchronizedSet(Set<A> set) {
  
  
    return Collections.synchronizedSet(set);
  
}


static <A> Set<A> identityHashSet() {
  return Collections.newSetFromMap(new IdentityHashMap());
}


static <A> Iterator<A> iterator(Iterable<A> c) {
  return c == null ? emptyIterator() : c.iterator();
}




static Map<String, Integer> findBot_cache = synchroHashMap();
static int findBot_timeout = 5000;

static DialogIO findBot(String searchPattern) {
  // first split off sub-bot suffix
  String subBot = null;
  int i = searchPattern.indexOf('/');
  if (i >= 0 && (isJavaIdentifier(searchPattern.substring(0, i)) || isInteger(searchPattern.substring(0, i)))) {
    subBot = searchPattern.substring(i+1);
    searchPattern = searchPattern.substring(0, i);
    if (!isInteger(searchPattern))
      searchPattern = "Multi-Port at " + searchPattern + ".";
  }
  
  // assume it's a port if it's an integer
  if (isInteger(searchPattern))
    return talkToSubBot(subBot, talkTo(parseInt(searchPattern)));
    
  if (eq(searchPattern, "remote"))
    return talkToSubBot(subBot, talkTo("second.tinybrain.de", 4999));
    
  Integer port = findBot_cache.get(searchPattern);
  if (port != null) try {
    DialogIO io = talkTo("localhost", port);
    io.waitForLine(/*findBot_timeout*/); // TODO: implement
    String line = io.readLineNoBlock();
    if (indexOfIgnoreCase(line, searchPattern) == 0) {
      call(io, "pushback", line); // put hello string back in
      return talkToSubBot(subBot, io);
    }
  } catch (Exception e) {
    e.printStackTrace();
  }
  
  List<ProgramScan.Program> bots = quickBotScan();
  
  // find top-level bots
  for (ProgramScan.Program p : bots) {
    if (indexOfIgnoreCase(p.helloString, searchPattern) == 0) { // strict matching - start of hello string only, but case-insensitive
      findBot_cache.put(searchPattern, p.port);
      return talkToSubBot(subBot, talkTo("localhost", p.port));
    }
  }
  
  // find sub-bots
  for (ProgramScan.Program p : bots) {
    String botName = firstPartOfHelloString(p.helloString);
    boolean isVM = startsWithIgnoreCase(p.helloString, "This is a JavaX VM.");
    boolean shouldRecurse = startsWithIgnoreCase(botName, "Multi-Port") || isVM;
        
    if (shouldRecurse) try {
      Map<Number, String> subBots = (Map) unstructure(sendToLocalBotQuietly(p.port, "list bots"));
      for (Number vport : subBots.keySet()) {
        String name = subBots.get(vport);
        if (startsWithIgnoreCase(name, searchPattern))
          return talkToSubBot(vport.longValue(), talkTo("localhost", p.port));
      }
    } catch (Throwable __e) { print(exceptionToStringShort(__e)); }
  }
        
  return null;
}


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

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


  static 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 boolean swic(String a, String b) {
  return startsWithIgnoreCase(a, b);
}


  static 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 boolean matchStart(String pat, String s) {
  return matchStart(pat, s, null);
}

// matches are as you expect, plus an extra item for the rest string
static boolean matchStart(String pat, String s, Matches matches) {
  if (s == null) return false;
  return matchStart(pat, parse3_cachedInput(s), matches);
}
  
static boolean matchStart(String pat, List<String> toks, Matches matches) {
  if (toks == null) return false;
  List<String> tokpat = parse3_cachedPattern(pat);
  if (toks.size() < tokpat.size()) return false;
  String[] m = match2(tokpat, toks.subList(0, tokpat.size()));
  //print(structure(tokpat) + " on " + structure(toks) + " => " + structure(m));
  if (m == null) return false;
  if (matches != null) {
    matches.m = new String[m.length+1];
    arraycopy(m, matches.m);
    matches.m[m.length] = joinSubList(toks, tokpat.size(), toks.size()); // for Matches.rest()
  }
  return true;
}


static String sendToLocalBotOpt(String bot, String text, Object... args) {
  if (bot == null) return null;
  text = format(text, args);
   DialogIO channel = findBot(bot); try {
  if (channel == null) {
    print(quote(bot) + " not found, skipping send: " + quote(text));
    return null;
  }
  try {
    channel.readLine();
    print(shorten(bot + "> " + text, 200));
    channel.sendLine(text);
    String s = channel.readLine();
    print(shorten(bot + "< " + s, 200));
    return s;
  } catch (Throwable e) {
    e.printStackTrace();
    return null;
  }
} finally { _close(channel); }}


static void cleanKillVM() { try {
  ping();
  assertNotOnAWTThread();
  cleanKillVM_noSleep();
  Object o = new Object();
  synchronized(o) { o.wait(); }
} catch (Exception __e) { throw rethrow(__e); } }

static void cleanKillVM_noSleep() {
  call(getJavaX(), "cleanKill");
}


static File userDir() {
  return new File(userHome());
}

static File userDir(String path) {
  return new File(userHome(), path);
}


static String fsI_flex(String s) {
  return startsWithDigit(s) ? "#" + s : s;
}


static boolean exposeMethods2_debug = false;

static String exposeMethods2(Object receiver, String s, List<String> methodNames) {
  return exposeMethods2(receiver, s, methodNames, null);
}

static String exposeMethods2(Object receiver, String s, List<String> methodNames,
  Lock lock) {
  Matches m = new Matches();
  if (exposeMethods2_debug) print("Received: " + s);
  if (match("call *", s, m)) {
    List l;
    if (isIdentifier(m.unq(0)))
      l = ll(m.unq(0));
    else
      l = (List) unstructure(m.unq(0)); // we used to have safeUnstructure here
    String method = getString(l, 0);
    if (!contains(methodNames, method))
      throw fail("Method not allowed: " + method);
    if (lock != null) lock.lock();
    try {
      if (exposeMethods2_debug) print("Calling: " + method);
      Object o = call(receiver, method, asObjectArray(subList(l, 1)));
      if (exposeMethods2_debug) print("Got: " + getClassName(o));
      return ok2(structure(o));
    } finally {
      if (lock != null) lock.unlock();
    }
  }
  if (match("list methods", s))
    return ok2(structure(methodNames));
  return null;
}


static int makeBot(String greeting) {
  return makeAndroid3(greeting).port;
}

static Android3 makeBot(Android3 a) {
  makeAndroid3(a);
  return a;
}

static Android3 makeBot(String greeting, Object responder) {
  Android3 a = new Android3(greeting);
  a.responder = makeResponder(responder);
  makeBot(a);
  return a;
}

static Android3 makeBot() {
  return makeAndroid3(defaultBotName());
}


static boolean sameSnippetID(String a, String b) {
  if (!isSnippetID(a) || !isSnippetID(b)) return false;
  return parseSnippetID(a) == parseSnippetID(b);
}


static File javaxDataDir_dir; // can be set to work on different base dir

static File javaxDataDir() {
  return javaxDataDir_dir != null ? javaxDataDir_dir : new File(userHome(), "JavaX-Data");
}

static File javaxDataDir(String... subs) {
  return newFile(javaxDataDir(), subs);
}


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


static Map<String, java.util.regex.Pattern> compileRegexp_cache = syncMRUCache(10);

static 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 List<File> listFilesOnly(String dir) {
  return listFilesOnly(new File(dir));
}

static List<File> listFilesOnly(File... dirs) {
  return concatMap(dir -> listFilesWithSuffix("", dir), dirs);
}


static <A, B> Comparator<A> mapComparator(final Map<A, B> map) {
  return new Comparator<A>() {
    public int compare(A a, A b) {
      return cmp(map.get(a), map.get(b));
    }
  };
}


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


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


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

// returns null on not found
// this is the simple version that is not case-tolerant
static 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 boolean startsWithAny(String a, Collection<String> b) {
  for (String prefix : unnullForIteration(b))
    if (startsWith(a, prefix))
      return true;
  return false;
}

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


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



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


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


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


static ClassLoader classLoaderForObject(Object o) {
  if (o instanceof ClassLoader) return ((ClassLoader) o);
  if (o == null) return null;
  return _getClass(o).getClassLoader();
}


// Note: This is actually broken. Inner classes must stay with a $ separator
static String classNameToVM(String name) {
  return name.replace(".", "$");
}


static HashMap litmap(Object... x) {
  HashMap map = new HashMap();
  litmap_impl(map, x);
  return map;
}

static 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 TreeSet<String> litciset(String... items) {
  TreeSet<String> set = caseInsensitiveSet();
  for (String a : items) set.add(a);
  return set;
}


static TreeSet<Symbol> litciset(Symbol... items) {
  TreeSet<Symbol> set = treeSet(); // HashSet would also do, but we might have the return type fixed somewhere, and they might want a NavigableMap.
  for (Symbol a : items) set.add(a);
  return set;
}



static String afterLastSpace(String s) {
  return s == null ? null : substring(s, s.lastIndexOf(' ')+1);
}


static <A> A[] dropLast(A[] a) { return dropLast(a, 1); }
static <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 <A> List<A> dropLast(List<A> l) {
  return subList(l, 0, l(l)-1);
}

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

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

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

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

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



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

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

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

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

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

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


static <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 boolean contains(Rect r, Pt p) { return rectContains(r, p); }



static String dropSuffixIgnoreCase(String suffix, String s) {
  return ewic(s, suffix) ? s.substring(0, l(s)-l(suffix)) : s;
}


static boolean ewicOneOf(String s, String... l) {
  if (s != null) for (String x : l) if (ewic(s, x)) return true; return false;
}


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

static <A> A vm_generalMap_getOrCreate(Object key, IF0<A> create) {
  Map generalMap = vm_generalMap();
  if (generalMap == null) return null; // must be x30 init
  
  synchronized(generalMap) { // should switch to locks here
    A a =  (A) (vm_generalMap_get(key));
    if (a == null)
      vm_generalMap_put(key, a = create == null ? null : create.get());
    return a;
  }
}




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



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



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



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


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


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



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



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


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

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

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

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


// TODO: optimize (use getOpt_cache)
static void setOpt_raw(Object o, String field, Object value) { try {
  if (o == null) return;
  if (o instanceof Class) setOpt_raw((Class) o, field, value);
  else {
    Field f = setOpt_raw_findField(o.getClass(), field);
    if (f != null) {
      makeAccessible(f);
      smartSet(f, o, value);
    }
  }
} catch (Exception __e) { throw rethrow(__e); } }

static void setOpt_raw(Class c, String field, Object value) { try {
  if (c == null) return;
  Field f = setOpt_raw_findStaticField(c, field);
  if (f != null) {
    makeAccessible(f);
    smartSet(f, null, value);
  }
} catch (Exception __e) { throw rethrow(__e); } }
  
static Field setOpt_raw_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);
  return null;
}

static Field setOpt_raw_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);
  return null;
}


static void smartSet(Field f, Object o, Object value) throws Exception {
  try {
    f.set(o, value);
  } catch (Exception e) {
    Class type = f.getType();
    
    // take care of common case (long to int)
    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 <A extends DynamicObject> A setDyn(A o, String key, Object value) {
  setDynObjectValue(o, key, value);
  return o;
}

static void setDyn(IMeta o, String key, Object value) {
  metaMapPut(o, key, value);
}


static Method fastIntern_method;

static 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 <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 <A, B, C extends Map<A, B>> C syncMapRemove_deleteMapIfEmpty(C map, A key) {
  if (map != null && key != null)
    synchronized(collectionMutex(map)) {
      map.remove(key);
      if (map.isEmpty())
        return null;
    }
  return map;
}


static boolean isInAnonymousClass(Object o) {
  if (o == null) return false;
  return isAnonymousClassName(className(o));
}


static <A, B> List<B> lambdaMap(IF1<A, B> f, Iterable<A> l) {
  return map(l, f);
}

static <A, B> List<B> lambdaMap(IF1<A, B> f, A[] l) {
  return map(l, f);
}


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


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


static void addToContainer(Container a, Component... b) {
  if (a == null) return;
  { swing(() -> { 
    for (Component c : unnullForIteration(b))
      if (c != null) 
        a.add(c);
  }); }
}


static Component wrapForSmartAdd(Object o) {
  if (o == null) return jpanel();
  if (o instanceof String) return jlabel((String) o);
  return wrap(o);
}


static void _onJavaXSet() {}


static <A> Set<A> syncLinkedHashSet() {
  return synchroLinkedHashSet();
}


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

static 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 <A> A popLast(List<A> l) {
  return liftLast(l);
}

static <A> List<A> popLast(int n, List<A> l) {
  return liftLast(n, l);
}




static List<AbstractButton> buttonsInGroup(ButtonGroup g) {
  if (g == null) return ll();
  return asList(g.getElements());
}


static boolean isInstance(Class type, Object arg) {
  return type.isInstance(arg);
}


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

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


static <A> HashSet<A> litset(A... items) {
  return lithashset(items);
}


static <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 <A, B> void multiMapPut(MultiMap<A, B> mm, A key, B value) {
  if (mm != null && key != null && value != null) mm.put(key, value);
}



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


static Object dm_getStem(Object moduleOrID) {
  if (isString(moduleOrID) && isIdentifier(((String) moduleOrID)))
    moduleOrID = dm_getService(((String) moduleOrID));
  if (isStringOrIntOrLong(moduleOrID))
    return dm_getStemByID(moduleOrID);
  return or(getOpt(dm_getModule(moduleOrID), "_host"), moduleOrID);
}


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

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

// starts searching from i-1
static <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 <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 BetterThreadLocal<PingSource> pingSource_tl_var = new BetterThreadLocal<PingSource>() {
  @Override
  public PingSource initialValue() {
    return ping_v3_pingSourceMaker().get(); 
  }
};

static BetterThreadLocal<PingSource> pingSource_tl() {
  return pingSource_tl_var;
}


static <A> Set<A> synchroHashSet() {
  return synchronizedSet(new HashSet<A>());
}



static Iterator emptyIterator() {
  return Collections.emptyIterator();
}




static 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 DialogIO talkToSubBot(final long vport, final DialogIO io) {
  return talkToSubBot(String.valueOf(vport), io);
}

static DialogIO talkToSubBot(final String subBot, final DialogIO io) {
  if (subBot == null) return io;
  return new talkToSubBot_IO(subBot, io);
}

static class talkToSubBot_IO extends DialogIO {
  String subBot;
  DialogIO io;
  
  talkToSubBot_IO(String subBot, DialogIO io) {
  this.io = io;
  this.subBot = subBot;}
  
  // delegate all but sendLine
  boolean isStillConnected() { return io.isStillConnected(); }
  String readLineImpl() { return io.readLineImpl(); }
  boolean isLocalConnection() { return io.isLocalConnection(); }
  Socket getSocket() { return io.getSocket(); }
  public void close() { try { io.close(); } catch (Exception __e) { throw rethrow(__e); } }

  void sendLine(String line) {
    io.sendLine(format3("please forward to bot *: *", subBot, line));
  }
}


static DialogIO talkTo(int port) {
  return talkTo("localhost", port);
}

static int talkTo_defaultTimeout = 10000; // This is the CONNECT timeout
static int talkTo_timeoutForReads = 0; // Timeout waiting for answers (0 = no timeout)

static ThreadLocal<Map<String, DialogIO>> talkTo_byThread = new ThreadLocal();

static DialogIO talkTo(String ip, int port) { try {
  String full = ip + ":" + port;
  Map<String, DialogIO> map = talkTo_byThread.get();
  if (map != null && map.containsKey(full)) return map.get(full);
  
  if (isLocalhost(ip) && port == vmPort()) return talkToThisVM();

  return new talkTo_IO(ip, port);
} catch (Exception __e) { throw rethrow(__e); } }

static class talkTo_IO extends DialogIO { 
  String ip;
  int port;
  Socket s;
  Writer w;
  BufferedReader in;
  
  talkTo_IO(String ip, int port) {
  this.port = port;
  this.ip = ip; try {
    s = new Socket();
    try {
      if (talkTo_timeoutForReads != 0)
        s.setSoTimeout(talkTo_timeoutForReads);
      s.connect(new InetSocketAddress(ip, port), talkTo_defaultTimeout);
    } catch (Throwable e) {
      throw fail("Tried talking to " + ip + ":" + port, e);
    }
  
    w = new OutputStreamWriter(s.getOutputStream(), "UTF-8");
    in = new BufferedReader(new InputStreamReader(s.getInputStream(), "UTF-8"));
  } catch (Exception __e) { throw rethrow(__e); } }
  
  boolean isLocalConnection() {
    return s.getInetAddress().isLoopbackAddress();
  }
  
  boolean isStillConnected() {
    return !(eos || s.isClosed());
  }
  
  void sendLine(String line) { try {
    Lock __0 = lock; lock(__0); try {
    w.write(line + "\n");
    w.flush();
  } finally { unlock(__0); } } catch (Exception __e) { throw rethrow(__e); } }
  
  String readLineImpl() { try {
    return in.readLine();
  } catch (Exception __e) { throw rethrow(__e); } }
  
  public void close() {
    try {
      if (!noClose) s.close();
    } catch (IOException e) {
      // whatever
    }
  }
  
  Socket getSocket() {
    return s;
  }
}


// works on lists and strings and null

static int indexOfIgnoreCase(List<String> a, String b) {
  return indexOfIgnoreCase(a, b, 0);
}

static int indexOfIgnoreCase(List<String> a, String b, int i) {
  int n = a == null ? 0 : a.size();
  for (; i < n; i++)
    if (eqic(a.get(i), b)) return i;
  return -1;
}

static int indexOfIgnoreCase(String[] a, String b) { return indexOfIgnoreCase(a, b, 0); }
static int indexOfIgnoreCase(String[] a, String b, int i) {
  int n = a == null ? 0 : a.length;
  for (; i < n; i++)
    if (eqic(a[i], b)) return i;
  return -1;
}

static int indexOfIgnoreCase(String a, String b) {
  return indexOfIgnoreCase_manual(a, b);
  /*Matcher m = Pattern.compile(b, Pattern.CASE_INSENSITIVE + Pattern.LITERAL).matcher(a);
  if (m.find()) return m.start(); else ret -1;*/
}

static int indexOfIgnoreCase(String a, String b, int i) {
  return indexOfIgnoreCase_manual(a, b, i);
}


static List<ProgramScan.Program> quickBotScan() {
  return ProgramScan.quickBotScan();
}

static List<ProgramScan.Program> quickBotScan(int[] preferredPorts) {
  return ProgramScan.quickBotScan(preferredPorts);
}

static List<ProgramScan.Program> quickBotScan(String searchPattern) {
  List<ProgramScan.Program> l = new ArrayList<ProgramScan.Program>();
  for (ProgramScan.Program p : ProgramScan.quickBotScan())
    if (indexOfIgnoreCase(p.helloString, searchPattern) == 0)
      l.add(p);
  return l;
}



static String firstPartOfHelloString(String s) {
  int i = s.lastIndexOf('/');
  return i < 0 ? s : rtrim(s.substring(0, i));
}


static boolean startsWithIgnoreCase(String a, String b) {
  return regionMatchesIC(a, 0, b, 0, b.length());
}




// TODO: cyclic structures involving certain lists & sets



static Object unstructure(String text) {
  return unstructure(text, false);
}

static Object unstructure(String text, boolean allDynamic) {
  return unstructure(text, allDynamic, null);
}

static Object unstructure(String text, IF1<String, Class> classFinder) {
  return unstructure(text, false, classFinder);
}

static int structure_internStringsLongerThan = 50;
static int unstructure_unquoteBufSize = 100;

static int unstructure_tokrefs; // stats

abstract static class unstructure_Receiver {
  abstract void set(Object o);
}

// classFinder: func(name) -> class (optional)
static Object unstructure(String text, boolean allDynamic,
  Object classFinder) {
  if (text == null) return null;
  return unstructure_tok(javaTokC_noMLS_iterator(text), allDynamic, classFinder);
}

static Object unstructure_reader(BufferedReader reader) {
  return unstructure_tok(javaTokC_noMLS_onReader(reader), false, null);
}

interface unstructure_Handler {
  void parse(int refID, int tokIndex, unstructure_Receiver out);
}
  
static class Unstructurer {
   final public Unstructurer setTok(Producer<String> tok){ return tok(tok); }
public Unstructurer tok(Producer<String> tok) { this.tok = tok; return this; }  final public Producer<String> getTok(){ return tok(); }
public Producer<String> tok() { return tok; }
 Producer<String> tok;
   final public Unstructurer setAllDynamic(boolean allDynamic){ return allDynamic(allDynamic); }
public Unstructurer allDynamic(boolean allDynamic) { this.allDynamic = allDynamic; return this; }  final public boolean getAllDynamic(){ return allDynamic(); }
public boolean allDynamic() { return allDynamic; }
 boolean allDynamic = false;
  int i = -1;
  Object classFinder;
  String mcDollar = actualMCDollar();
  
  Unstructurer classFinder(Object _classFinder) {
    classFinder = _classFinder != null ? _classFinder : _defaultClassFinder();
    return this;
  }

  // use Eclipse primitive collection if possible (smaller & hopefully faster?)
  
  
  HashMap<Integer, Object> refs = new HashMap();
  HashMap<Integer, Object> tokrefs = new HashMap();
  
  
  HashSet<String> concepts = new HashSet();
  List<Runnable> stack = new ArrayList();
  Map<String, String> baseClassMap = new HashMap();
  HashMap<Class, Constructor> innerClassConstructors = new HashMap();
  String curT;
  char[] unquoteBuf = new char[unstructure_unquoteBufSize];
  
  // value is a class or a Handler
  final HashMap<String, Object> handlers = new HashMap();
  
  Unstructurer() {
    try {
      Class mc =  (Class) (callF(classFinder, "<main>"));
      if (mc != null) mcDollar = mc.getName() + "$";
    } catch (Throwable __e) { pcallFail(__e); }
    
    makeHandlers();
  }
  
  
  
  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);
    handlers.put("floatarray", h);
    
    handlers.put("shortarray", (unstructure_Handler) (refID, tokIndex, out) -> {
      consume();
      String hex = trivialUnquote(tpp());
      out.set(shortArrayFromBytes(hexToBytes(hex)));
    });
    
    handlers.put("longarray", (unstructure_Handler) (refID, tokIndex, out) -> {
      consume();
      String hex = trivialUnquote(tpp());
      out.set(longArrayFromBytes(hexToBytes(hex)));
    });
  } // end of makeHandlers - add more handlers here

  Class findAClass(String fullClassName) { try {
    return classFinder != null ? (Class) callF(classFinder, fullClassName) : findClass_fullName(fullClassName);
  } catch (Throwable __e) { return null; } }
  
  String unquote(String s) {
    return unquoteUsingCharArray(s, unquoteBuf); 
  }

  // look at current token
  String t() {
    return curT;
  }
  
  // get current token, move to next
  String tpp() {
    String t = curT;
    consume();
    return t;
  }
  
  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;
    
    // if (debug) print("parse: " + quote(t));
    
    final int tokIndex = i;  
    parse_inner(refID, tokIndex, new unstructure_Receiver() {
      void set(Object o) {
        if (refID >= 0)
          refs.put(refID, o);
        if (o != null)
          tokrefs.put(tokIndex, o);
        out.set(o);
      }
    });
  }
  
  void parse_inner(int refID, int tokIndex, unstructure_Receiver out) {
    String t = t();
    
    // if (debug) print("parse_inner: " + quote(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 (debug) print("isLongConstant " + quote(t) + " => " + isLongConstant(t));
        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 (debug) print("isLongConstant " + quote(t) + " => " + isLongConstant(t));
        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")) { // legacy
        consume();
        { parseList(synchroLinkedList(), out); return; }
      }

      if (t.equals("sync")) {
        consume();
        { parse(new unstructure_Receiver() {
          void set(Object value) {
            if (value instanceof Map) {
               // Java 7
              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 = trivialUnquote(tpp());
        out.set(hexToBytes(hex)); return;
      }
      if (t.equals("boolarray")) {
        consume();
        int n = parseInt(tpp());
        String hex = trivialUnquote(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);
      }
      
      // custom deserialization (new static method method)
      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() {
          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; }
    }
    
    // add more tokens here

    // Now we want to find our target class c
    // Have we failed to look up the class before?
    //bool seenBefore = handlers.containsKey(cname);

    // If we have seen the class before, we skip all of this
    // and simply leave c as null
    // TODO - how do we fill className?
    //if (!seenBefore) {
      if (c == null && !isJavaIdentifier(t))
        throw new RuntimeException("Unknown token " + (i+1) + ": " + quote(t));
        
      // any other class name (or package name)
      consume();
      String className, fullClassName;
      
      // Is it a package name?
      if (eq(t(), ".")) {
        className = t;
        do {
          consume();
          className += "." + assertIdentifier(tpp());
        } while (eq(t(), "."));
        fullClassName = className;
      } else {
        className = t;
        fullClassName = mcDollar + t;
      }
      
      if (c == null && !allDynamic) {
        // First, find class
        c = findAClass(fullClassName);
        handlers.put(className, c);
      }
      
      // check for existing base class
      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;
        }
      }
    //}
        
    // Check if it has an outer reference
    boolean hasBracket = eq(t(), "(");
    if (hasBracket) consume();
    boolean hasOuter = hasBracket && startsWith(t(), "this$");
    
    DynamicObject dO = null;
    Object o = null;
    final String thingName = t;
    try {
      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;
        
      }
    } catch (Throwable __e) { pcallFail(__e); } // end of pcall
    
    // Creating instance failed? Use DynamicObject
    if (o == null && dO == null)
      dO = new DynamicObject();
    
    // Save in references list early because contents of object
    // might link back to main object
    
    if (refID >= 0)
      refs.put(refID, o != null ? o : dO);
    tokrefs.put(tokIndex, o != null ? o : dO);
    
    // NOW parse the fields!
    
    HashMap<String, Object> fields = new HashMap(); // no longer preserving order (why did we do this?)
    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 /*+ " " + sfu(fields)*/);
          stack.add(this);
          parse(new unstructure_Receiver() {
            void set(Object value) {
              fields.put(key, value);
              /*ifdef unstructure_debug
                print("Got field value " + value + ", next token: " + t());
              endifdef*/
              //if (eq(t(), ",")) consume();
            }
          });
        }
      
} catch (Exception __e) { throw rethrow(__e); } }  public String toString() { return "ifdef unstructure_debug\r\n          print(\"in object values, token: \" + t());\r..."; }});
    } else {
      objRead(o, dO, fields, hasOuter);
      out.set(o != null ? o : dO);
    }
  }
  
  void objRead(Object o, DynamicObject dO, Map<String, Object> fields, boolean hasOuter) {
    
    
    // translate between diferent compilers (this$0 vs this$1)
    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");
  }
  
  void parseSet(final Set set, final unstructure_Receiver out) {
    this.parseList(new ArrayList(), new unstructure_Receiver() {
      void set(Object o) {
        set.addAll((List) o);
        out.set(set);
      }
    });
  }
  
  void parseLisp(final unstructure_Receiver out) {
    
    
    throw fail("class Lisp not included");
  }
  
  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() {
          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      } els..."; }});
  }
  
  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() {
          void set(Object o) {
            //if (debug) print("List element type: " + getClassName(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\n   ..."; }});
  }
  
  void parseArray(unstructure_Receiver out) {
    String _type = tpp();
    int dims;

    if (eq(t(), "S")) { // string array
      _type = "S";
      consume();
    }
    
    if (eq(t(), "/")) { // multi-dimensional array
      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("floatarray") ? toFloatArray(list)
            : type.equals("S") ? toStringArray(list)
            : list.toArray());
      } else {
        stack.add(this);
        parse(new unstructure_Receiver() {
          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        ..."; }});
  }
  
  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);
    dynamicObject_setRawFieldValue(dO, "name", name);
    return dO;
  }
  
  Object parseBigInt() {
    consume("bigint");
    consume("(");
    String val = tpp();
    if (eq(val, "-"))
      val = "-" + tpp();
    consume(")");
    return new BigInteger(val);
  }
  
  Object parseDouble() {
    consume("d");
    consume("(");
    String val = unquote(tpp());
    consume(")");
    return Double.parseDouble(val);
  }
  
  Object parseFloat() {
    consume("fl");
    String val;
    if (eq(t(), "(")) {
      consume("(");
      val = unquote(tpp());
      consume(")");
    } else {
      val = unquote(tpp());
    }
    return Float.parseFloat(val);
  }
  
  void parseHashSet(unstructure_Receiver out) {
    consume("hashset");
    parseSet(new HashSet(), out);
  }
  
  void parseLinkedHashSet(unstructure_Receiver out) {
    consume("lhs");
    parseSet(new LinkedHashSet(), out);
  }
  
  void parseTreeSet(unstructure_Receiver out) {
    consume("treeset");
    parseSet(new TreeSet(), out);
  }
  
  void parseCISet(unstructure_Receiver out) {
    consume("ciset");
    parseSet(ciSet(), out);
  }
  
  void parseMap(unstructure_Receiver out) {
    parseMap(new TreeMap(), out);
  }
  
  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;
    }
  }
  
  void parseMap(final Map map, final unstructure_Receiver out) {
    consume("{");
    stack.add(new Runnable() {
      boolean v = false;
      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() {
            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() {
              void set(Object o) {
                key = o;
              }
            });
          }
        } // if v else
      } // run()
    });
  }
  
  /*void parseSub(unstructure_Receiver out) {
    int n = l(stack);
    parse(out);
    while (l(stack) > n)
      stack
  }*/
  
  void consume() { curT = tok.next(); ++i; }
  
  void consume(String s) {
    if (!eq(t(), s)) {
      /*S prevToken = i-1 >= 0 ? tok.get(i-1) : "";
      S nextTokens = join(tok.subList(i, Math.min(i+2, tok.size())));
      fail(quote(s) + " expected: " + prevToken + " " + nextTokens + " (" + i + "/" + tok.size() + ")");*/
      throw fail(quote(s) + " expected, got " + quote(t()));
    }
    consume();
  }
  
  // outer wrapper function getting first token and unwinding the stack
  void parse_initial(unstructure_Receiver out) {
    consume(); // get first token
    parse(out);
    while (nempty(stack))
      popLast(stack).run();
  }
}

static Object unstructure_tok(Producer<String> tok, boolean allDynamic, Object classFinder) {
  boolean debug = unstructure_debug;
   AutoCloseable __1 = tempSetTL(dynamicObjectIsLoading_threadLocal(), true); try {
  Var v = new Var();
  var unstructurer = new Unstructurer()
    .tok(tok)
    .allDynamic(allDynamic)
    .classFinder(classFinder);
  unstructurer.parse_initial(new unstructure_Receiver() {
    void set(Object o) { v.set(o); }
  });
  unstructure_tokrefs = unstructurer.tokrefs.size();
  return v.get();
} finally { _close(__1); }}

static boolean unstructure_debug = false;


static String sendToLocalBotQuietly(String bot, String text, Object... args) {
  text = format3(text, args);
  
   DialogIO channel = newFindBot2(bot); try {
  if (channel == null)
    throw fail(quote(bot) + " not found");
  try {
    channel.readLine();
    channel.sendLine(text);
    String s = channel.readLine();
    return s;
  } catch (Throwable e) {
    e.printStackTrace();
    return null;
  }
} finally { _close(channel); }}

static String sendToLocalBotQuietly(int port, String text, Object... args) {
  text = format3(text, args);
   DialogIO channel = talkTo(port); try {
  try {
    channel.readLine();
    channel.sendLine(text);
    String s = channel.readLine();
    return s;
  } catch (Throwable e) {
    e.printStackTrace();
    return null;
  }
} finally { _close(channel); }}


static String exceptionToStringShort(Throwable e) {
  try {
    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;
  } catch (Throwable _e) { printStackTrace(_e);
    return "Error in exceptionToStringShort";
  }
}


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




static Map<String, List<String>> parse3_cachedInput_cache = synchronizedMRUCache(1000);

static List<String> parse3_cachedInput(String s) {
  List<String> tok = parse3_cachedInput_cache.get(s);
  if (tok == null) parse3_cachedInput_cache.put(s, tok = parse3(s));
  return tok;
}






static Map<String, List<String>> parse3_cachedPattern_cache = synchronizedMRUCache(1000);

static synchronized List<String> parse3_cachedPattern(String s) {
  List<String> tok = parse3_cachedPattern_cache.get(s);
  if (tok == null) parse3_cachedPattern_cache.put(s, tok = parse3(s));
  return tok;
}




// match2 matches multiple "*" (matches a single token) wildcards and zero or one "..." wildcards (matches multiple tokens)

static String[] match2(List<String> pat, List<String> tok) {
  // standard case (no ...)
  int i = pat.indexOf("...");
  if (i < 0) return match2_match(pat, tok);
  
  pat = new ArrayList<String>(pat); // We're modifying it, so copy first
  pat.set(i, "*");
  while (pat.size() < tok.size()) {
    pat.add(i, "*");
    pat.add(i+1, ""); // doesn't matter
  }
  
  return match2_match(pat, tok);
}

static 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))) // bold change - match quoted and unquoted now. TODO: should remove
      return null;
  }
  return result.toArray(new String[result.size()]);
}



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

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




  static String format(String pat, Object... args) {
    return format3(pat, args);
  }



static int shorten_default = 100;

static String shorten(CharSequence s) { return shorten(s, shorten_default); }

static String shorten(CharSequence s, int max) {
  return shorten(s, max, "...");
}

static 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 String shorten(int max, CharSequence s) { return shorten(s, max); }


static void assertNotOnAWTThread() {
  assertFalse("Can't do this in AWT thread", isAWTThread());
}
  


static boolean startsWithDigit(String s) {
  return nempty(s) && isDigit(s.charAt(0));
}


static boolean match(String pat, String s) {
  return match3(pat, s);
}

static boolean match(String pat, String s, Matches matches) {
  return match3(pat, s, matches);
}

static boolean match(String pat, List<String> toks, Matches matches) {
  return match3(pat, toks, matches);
}


static String getString(Map map, Object key) {
  return map == null ? null : (String) map.get(key);
}

static String getString(List l, int idx) {
  return (String) get(l, idx);
}

static String getString(Object o, Object key) {
  if (o instanceof Map) return getString((Map) o, key);
  if (key instanceof String)
    return (String) getOpt(o, (String) key);
  throw fail("Not a string key: " + getClassName(key));
}

static String getString(String key, Object o) {
  return getString(o, (Object) key);
}


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

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

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

static <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 String ok2(String s) {
  return "ok " + s;
}


static boolean structure_showTiming, structure_checkTokenCount;

static String structure(Object o) {
  return structure(o, new structure_Data());
}

static String structure(Object o, structure_Data d) {
  StringWriter sw = new StringWriter();
  d.out = new PrintWriter(sw);
  structure_go(o, d);
  String s = str(sw);
  if (structure_checkTokenCount) {
    print("token count=" + d.n);
    assertEquals("token count", l(javaTokC(s)), d.n);
  }
  return s;
}

static void structure_go(Object o, structure_Data d) {
  structure_1(o, d);
  while (nempty(d.stack))
    popLast(d.stack).run();
}

static void structureToPrintWriter(Object o, PrintWriter out) { structureToPrintWriter(o, out, new structure_Data()); }
static void structureToPrintWriter(Object o, PrintWriter out, structure_Data d) {
  d.out = out;
  structure_go(o, d);
}

// leave to false, unless unstructure() breaks
static boolean structure_allowShortening = false;

// info on how to serialize objects of a certain class
static class structure_ClassInfo<A> {
  Class c;
  String shortName;
  List<Field> fields;
  Method customSerializer;
  IVF1<Object> serializeObject; // can be set by caller of structure function
  boolean special = false; // various special classes
  boolean nullInstances = false; // serialize all instances as null (e.g. lambdas/anonymous classes)
  boolean javafy = false; // always convert to "j ..."
  Object emptyInstance; // to grab default field values from
  
  public String toString() {
    return commaCombine(
      "Class " + className(c),
      stringIf("special", special),
      stringIf("customSerializer", customSerializer != null),
      stringIf("javafy", javafy),
      stringIf("nullInstances", nullInstances));
  }
  
  void nullInstances(boolean b) {
    this.nullInstances = b;
    if (b) special = true;
  }
  
  void javafy(boolean b) {
    this.javafy = b;
    if (b) special = true;
  }
  
  // overridable - return true if you wrote the object
  boolean handle(A o) { return false; }
}

static class structure_Data {
  PrintWriter out;
  int stringSizeLimit;
  int shareStringsLongerThan = 20;
  boolean noStringSharing = false;
  boolean storeBaseClasses = false;
  boolean honorFieldOrder = true;
  String mcDollar = actualMCDollar();
   final public structure_Data setWarnIfUnpersistable(boolean warnIfUnpersistable){ return warnIfUnpersistable(warnIfUnpersistable); }
public structure_Data warnIfUnpersistable(boolean warnIfUnpersistable) { this.warnIfUnpersistable = warnIfUnpersistable; return this; }  final public boolean getWarnIfUnpersistable(){ return warnIfUnpersistable(); }
public boolean warnIfUnpersistable() { return warnIfUnpersistable; }
 boolean warnIfUnpersistable = true;
   final public structure_Data setStackTraceIfUnpersistable(boolean stackTraceIfUnpersistable){ return stackTraceIfUnpersistable(stackTraceIfUnpersistable); }
public structure_Data stackTraceIfUnpersistable(boolean stackTraceIfUnpersistable) { this.stackTraceIfUnpersistable = stackTraceIfUnpersistable; return this; }  final public boolean getStackTraceIfUnpersistable(){ return stackTraceIfUnpersistable(); }
public boolean stackTraceIfUnpersistable() { return stackTraceIfUnpersistable; }
 boolean stackTraceIfUnpersistable = true;
  
  // skip a field if it has the default value defined in the class
  // -slower, and may cause issues with schema evolution
  // -OTOH, it can serialize null values for a field with default non-null value
   final public structure_Data setSkipDefaultValues(boolean skipDefaultValues){ return skipDefaultValues(skipDefaultValues); }
public structure_Data skipDefaultValues(boolean skipDefaultValues) { this.skipDefaultValues = skipDefaultValues; return this; }  final public boolean getSkipDefaultValues(){ return skipDefaultValues(); }
public boolean skipDefaultValues() { return skipDefaultValues; }
 boolean skipDefaultValues = false;
  
  structure_Data d() { return this; }

  transient  IF1<Field, Boolean> shouldIncludeField;
boolean shouldIncludeField(Field f) { return shouldIncludeField != null ? shouldIncludeField.get(f) : shouldIncludeField_base(f); }
final boolean shouldIncludeField_fallback(IF1<Field, Boolean> _f, Field f) { return _f != null ? _f.get(f) : shouldIncludeField_base(f); }
boolean shouldIncludeField_base(Field f) { return true; }

  IdentityHashMap<Object, Integer> seen = new IdentityHashMap();
  //new BitSet refd;
  HashMap<String, Integer> strings = new HashMap();
  HashSet<String> concepts = new HashSet();
  HashMap<Class, structure_ClassInfo> infoByClass = new HashMap();
  
  // wrapper for _persistenceInfo field or _persistenceInfo method
  // by class (taking the object instance)
  HashMap<Class, IF1<Object, Map>> persistenceInfo = new HashMap();
  
  int n; // token count
  List<Runnable> stack = new ArrayList();
  
  // append single token
  structure_Data append(String token) { out.print(token); ++n; return this; }
  structure_Data append(int i) { out.print(i); ++n; return this; }
  
  // append multiple tokens
  structure_Data append(String token, int tokCount) { out.print(token); n += tokCount; return this; }
  
  // extend last token
  structure_Data app(String token) { out.print(token); return this; }
  structure_Data app(int i) { out.print(i); return this; }
  structure_Data app(char c) { out.print(c); return this; }

  structure_ClassInfo infoForClass(Class c) {
    structure_ClassInfo info = infoByClass.get(c);
    if (info == null) info = newClass(c);
    return info;
  }
  
  transient  IF1<String, String> realShortName;
String realShortName(String name) { return realShortName != null ? realShortName.get(name) : realShortName_base(name); }
final String realShortName_fallback(IF1<String, String> _f, String name) { return _f != null ? _f.get(name) : realShortName_base(name); }
String realShortName_base(String name) {
    return dropPrefix("main$",
      dropPrefix("loadableUtils.utils$",
        dropPrefix(mcDollar, name)));
  }
  
  // called when a new class is detected
  // can be overridden by clients
  structure_ClassInfo newClass(Class c) {
    // special classes here!
    
    var d = d();
    boolean isJavaXClass = isJavaXClassName(c.getName(), mcDollar);
     
    
    if (c == String.class)
      return new structure_ClassInfo<String>() {
        @Override boolean handle(String o) {
          String s = d.stringSizeLimit != 0 ? shorten((String) o, d.stringSizeLimit) : (String) o;
          if (!d.noStringSharing) {
            if (d.shareStringsLongerThan == Integer.MAX_VALUE)
              d.seen.put(o, d.n);
            if (l(s) >= d.shareStringsLongerThan)
              d.strings.put(s, d.n);
          }
          quoteToPrintWriter(s, d.out); d.n++;
          return true;
        }
      };

    
    if (c == File.class)
      return new structure_ClassInfo<File>() {
        @Override boolean handle(File o) {
          append("File ").append(quote(o.getPath()));
          return true;
        }
      };

    if (!isJavaXClass) {
      if (isSubClassOf(c, Set.class))
        return new structure_ClassInfo<Set>() {
          @Override boolean handle(Set o) {
            writeSet(o);
            return true;
          }
        };

      if (isSubClassOf(c, Collection.class))
        return new structure_ClassInfo<Collection>() {
          @Override boolean handle(Collection o) {
            writeCollection(o);
            return true;
          }
        };
        
      if (isSubClassOf(c, Map.class))
        return new structure_ClassInfo<Map>() {
          @Override boolean handle(Map o) {
            writeMap(o);
            return true;
          }
        };
    }

    structure_ClassInfo info = new structure_ClassInfo();
    info.c = c;
    infoByClass.put(c, info);
    
    String name = c.getName();
    String shortName = realShortName(name);
    if (startsWithDigit(shortName)) shortName = name; // for anonymous classes
    info.shortName = shortName;
    
    try {
      if (isSyntheticOrAnonymous(c)) {
        info.nullInstances(true);
        return info;
      }
      
      if (c.isEnum()) {
        info.special = true;
        return info;
      }
      
      

      if (c.isArray()) {
        // info.special?
        return info;
      }
      
      if ((info.customSerializer = findMethodNamed(c, "_serialize"))
        != null) info.special = true;
        
      if (storeBaseClasses) {
        Class sup = c.getSuperclass();
        if (sup != Object.class) {
          append("bc ");
          append(shortDynClassNameForStructure(c));
          out.print(" ");
          append(shortDynClassNameForStructure(sup));
          out.print(" ");
          infoForClass(sup); // transitively write out superclass relations
        }
      }
      
      if (eqOneOf(name, "java.awt.Color", "java.lang.ThreadLocal"))
        info.javafy(true);
      else if (name.startsWith("sun") || !isPersistableClass(c)) {
        info.javafy(true);
        if (warnIfUnpersistable) {
          String msg = "Class not persistable: " + c + " (anonymous or no default constructor), referenced from " + last(stack);
          if (stackTraceIfUnpersistable)
            printStackTrace(new Throwable(msg));
          else
            print(msg);
        }
      } else if (skipDefaultValues) {
        var ctor = getDefaultConstructor(c);
        if (ctor != null)
          info.emptyInstance = invokeConstructor(ctor);
      }
    } catch (Throwable e) { printStackTrace(e);
      info.nullInstances(true);
    }
    
    return info;
  }
  
  void setFields(structure_ClassInfo info, List<Field> fields) { 
    info.fields = fields;
  }
  
  void writeObject(Object o, String shortName, Map<String, Object> fv) {
    String singleField = fv.size() == 1 ? first(fv.keySet()) : null;
  
    append(shortName);
    n += countDots(shortName)*2; // correct token count
    
  
    int l = n;
    Iterator it = fv.entrySet().iterator();
    
    class WritingObject implements Runnable {
      String lastFieldWritten;
      
      public void run() { try {
        if (!it.hasNext()) {
          if (n != l)
            append(")");
        } else {
          Map.Entry e =  (Map.Entry) (it.next());
          append(n == l ? "(" : ", ");
          append(lastFieldWritten = (String) e.getKey()).append("=");
          stack.add(this);
          structure_1(e.getValue(), structure_Data.this);
        }
      } catch (Exception __e) { throw rethrow(__e); } }
      
      public String toString() { return shortName + "." + lastFieldWritten; }
    }
    
    stack.add(new WritingObject());
  }
  
  void writeMap(Map o) {
    var d = this;
    String name = o.getClass().getName();
    if (o instanceof LinkedHashMap) d.append("lhm");
    else if (o instanceof HashMap) d.append("hm");
    else if (o instanceof TreeMap)
      d.append(isCIMap_gen((TreeMap) o) ? "cimap" : "tm");
    else if (name.equals("java.util.Collections$SynchronizedMap")
      || name.equals("java.util.Collections$SynchronizedSortedMap")
      || name.equals("java.util.Collections$SynchronizedNavigableMap")) {
      d.append("sync "); 
      { structure_1(unwrapSynchronizedMap(((Map) o)), d); return; }
    }
    
    d.append("{");
    final int l = d.n;
    final Iterator it = cloneMap((Map) o).entrySet().iterator();
    
    class WritingMap implements Runnable {
      boolean v = false;
      Map.Entry e;
      
      public String toString() {
        return renderVars("WritingMap", "e" , mapEntryToPair(e), "v" , !v);
      }
      
      public void run() { try {
        if (v) {
          d.append("=");
          v = false;
          d.stack.add(this);
          structure_1(e.getValue(), d);
        } else {
          if (!it.hasNext())
            d.append("}");
          else {
            e = (Map.Entry) it.next();
            v = true;
            d.stack.add(this);
            if (d.n != l) d.append(", ");
            structure_1(e.getKey(), d);
          }
        }
      } catch (Exception __e) { throw rethrow(__e); } }
    }
    
    d.stack.add(new WritingMap());
  }

  void writeSet(Set o) {
    var d = this;
    String name = o.getClass().getName();
    
    /*O set2 = unwrapSynchronizedSet(o);
    if (set2 != o) {
      d.append("sync");
      o = set2;
    } TODO */
    
    if (o instanceof TreeSet) {
      d.append(isCISet_gen(o) ? "ciset" : "treeset");
      structure_1(new ArrayList(o), d);
      return;
    }
    
    // assume it's a HashSet or LinkedHashSet
    d.append(o instanceof LinkedHashSet ? "lhs" : "hashset");
    structure_1(new ArrayList(o), d);
  }

  void writeCollection(Collection o) {
    var d = this;
    String name = o.getClass().getName();
    
     
    
    if (name.equals("java.util.Collections$SynchronizedList")
      || name.equals("java.util.Collections$SynchronizedRandomAccessList")) {
      d.append("sync ");
      { structure_1(unwrapSynchronizedList(((List) o)), d); return; }
    }
    else if (name.equals("java.util.LinkedList"))
      d.append("ll");
    d.append("[");
    int l = d.n;
    Iterator it = cloneList(o).iterator();
    d.stack.add(new Runnable() {  public void run() { try { 
      if (!it.hasNext())
        d.append("]");
      else {
        d.stack.add(this);
        if (d.n != l) d.append(", ");
        structure_1(it.next(), d);
      }
    
} catch (Exception __e) { throw rethrow(__e); } }  public String toString() { return "if (!it.hasNext())\r\n        d.append(\"]\");\r\n      else {\r\n        d.stack.add..."; }});
  }
} // end of class structure_Data

static void structure_1(Object o, structure_Data d) { try {
  if (o == null) { d.append("null"); return; }
  
  Class c = o.getClass();
  boolean concept = false;
  
    concept = o instanceof Concept;
  
  structure_ClassInfo info = d.infoForClass(c);
  
   

  boolean isJavaXName = isJavaXClassName(c.getName(), d.mcDollar);
  
  boolean referencable = isJavaXName &&
    !(o instanceof Number || o instanceof Character || o instanceof Boolean)
    || o instanceof Collection || o instanceof Map;
    
   
  
  if (referencable) {
    Integer ref = d.seen.get(o);
    if (ref != null) {
       
      //d.refd.set(ref);
      d.append("t").app(ref);
      return;
    }
    
    d.seen.put(o, d.n); // record token number
     
  }
      
  if (info.handle(o)) {
     
    return;
  }
  
  if (info.special) {
    if (info.javafy) {
      d.append("j ").append(quote(str(o))); return; // This is not unstructure-able except for java.awt.Color
    }
    
    if (c.isEnum()) {
      d.append("enum ");
      d.append(info.shortName);
      d.out.append(' ');
      d.append(((Enum) o).ordinal());
      return;
    }
    
    if (info.customSerializer != null) {
      // custom serialization (_serialize method)
      Object o2 = invokeMethod(info.customSerializer, o);
      if (o2 == o) {} // bail out to standard serialization
      else {
        d.append("cu ");
        String name = c.getName();
        String shortName = d.realShortName(name);
        d.append(shortName);
        d.out.append(' ');
        structure_1(o2, d);
        return;
      }
    } else if (info.nullInstances) { d.append("null"); return; }
    else if (info.serializeObject != null)
      { info.serializeObject.get(o); return; }
    else throw fail("unknown special type");
  }
    
  List<Field> lFields = info.fields;
  if (lFields == null) {
    // these are never back-referenced (for readability)
    
    if (o instanceof Number) {
      PrintWriter out = d.out;
if (o instanceof Integer) { int i = ((Integer) o).intValue(); out.print(i); d.n += i < 0 ? 2 : 1; return; }
      if (o instanceof Long) { long l = ((Long) o).longValue(); out.print(l); out.print("L"); d.n += l < 0 ? 2 : 1; return; }
      if (o instanceof Short) { short s = ((Short) o).shortValue(); d.append("sh "); out.print(s); d.n += s < 0 ? 2 : 1; return; }
      if (o instanceof Float) { d.append("fl ", 2); quoteToPrintWriter(str(o), out); return; }
      if (o instanceof Double) { d.append("d(", 3); quoteToPrintWriter(str(o), out); d.append(")"); return; }
      if (o instanceof BigInteger) { out.print("bigint("); out.print(o); out.print(")"); d.n += ((BigInteger) o).signum() < 0 ? 5 : 4; return; }
    }
  
    if (o instanceof Boolean) {
      d.append(((Boolean) o).booleanValue() ? "t" : "f"); return;
    }
      
    if (o instanceof Character) {
      d.append(quoteCharacter((Character) o)); return;
    }
      
    String name = c.getName();
    
    if (!isJavaXName) {
      if (o instanceof Set)
        { d.writeSet((Set) o); return; }
      
      if (o instanceof Collection
        /* && neq(name, "main$Concept$RefL") */) {
        
        { d.writeCollection((Collection) o); return; }
      }
    
      if (o instanceof Map)
        { d.writeMap((Map) o); return; }
    }
    
    if (c.isArray()) {
      if (o instanceof byte[]) {
        d.append("ba ").append(quote(bytesToHex((byte[]) o))); return;
      }
  
      final int n = Array.getLength(o);
  
      if (o instanceof boolean[]) {
        String hex = boolArrayToHex((boolean[]) o);
        int i = l(hex);
        while (i > 0 && hex.charAt(i-1) == '0' && hex.charAt(i-2) == '0') i -= 2;
        d.append("boolarray ").append(n).app(" ").append(quote(substring(hex, 0, i))); return;
      }
      
      if (o instanceof short[]) {
        String hex = shortArrayToHex_bigEndian((short[]) o);
        d.append("shortarray \"").append(hex).app('\"');
        return;
      }
      
      if (o instanceof long[]) {
        String hex = longArrayToHex_bigEndian((long[]) o);
        d.append("longarray \"").append(hex).app('\"');
        return;
      }
      
      String atype = "array"/*, sep = ", "*/; // sep is not used yet
  
      if (o instanceof int[]) {
        //ret "intarray " + quote(intArrayToHex((int[]) o));
        atype = "intarray";
        //sep = " ";
      } else if (o instanceof double[]) {
        atype = "dblarray";
        //sep = " ";
      } else if (o instanceof float[]) {
        atype = "floatarray";
      } else {
        // 2-dimensional and deeper arrays
        Pair<Class, Integer> p = arrayTypeAndDimensions(c);
        if (p.a == int.class) atype = "intarray";
        else if (p.a == byte.class) atype = "bytearray";
        else if (p.a == boolean.class) atype = "boolarray";
        else if (p.a == double.class) atype = "dblarray";
        else if (p.a == float.class) atype = "floatarray";
        else if (p.a == String.class) { atype = "array S"; d.n++; }
        else atype = "array"; // fail("Unsupported array type: " + p.a);
        if (p.b > 1) {
          atype += "/" + p.b; // add number of dimensions
          d.n += 2; // 2 additional tokens will be written
        }
      }
      
      d.append(atype).append("{");
      d.stack.add(new Runnable() {
        int i;
        public void run() {
          if (i >= n)
            d.append("}");
          else {
            d.stack.add(this);
            if (i > 0) d.append(", ");
            structure_1(Array.get(o, i++), d);
          }
        }
      });
      return;
    }
  
    if (o instanceof Class) {
      d.append("class(", 2).append(quote(((Class) o).getName())).append(")"); return;
    }
      
    if (o instanceof Throwable) {
      d.append("exception(", 2).append(quote(((Throwable) o).getMessage())).append(")"); return;
    }
      
    if (o instanceof BitSet) {
      BitSet bs = (BitSet) o;
      d.append("bitset{", 2);
      int l = d.n;
      for (int i = bs.nextSetBit(0); i >= 0; i = bs.nextSetBit(i+1)) {
        if (d.n != l) d.append(", ");
        d.append(i);
      }
      d.append("}"); return;
    }
      
    
      
    /*if (name.equals("main$Lisp")) {
      fail("lisp not supported right now");
    }*/
    
    String dynName = shortDynClassNameForStructure(o);
    if (concept && !d.concepts.contains(dynName)) {
      d.concepts.add(dynName);
      d.append("c ");
    }
    
    // serialize an object with fields.
    // first, collect all fields and values in fv.
    
    TreeSet<Field> fields = new TreeSet<Field>(new Comparator<Field>() {
      public int compare(Field a, Field b) {
        return stdcompare(a.getName(), b.getName());
      }
    });
    
    Class cc = c;
    while (cc != Object.class) {
      for (Field field : getDeclaredFields_cached(cc)) {
        if (!d.shouldIncludeField(field)) continue;
        
        String fieldName = field.getName();
        if (fieldName.equals("_persistenceInfo"))
          d.persistenceInfo.put(c, obj -> (Map) fieldGet(field, obj));
        if ((field.getModifiers() & (java.lang.reflect.Modifier.STATIC | java.lang.reflect.Modifier.TRANSIENT)) != 0)
          continue;

        fields.add(field);
        
        // put special cases here...?
      }
        
      cc = cc.getSuperclass();
    }
    
    Method persistenceInfoMethod = findInstanceMethod(c, "_persistenceInfo");
    if (persistenceInfoMethod != null)
      d.persistenceInfo.put(c, obj -> (Map) invokeMethod(persistenceInfoMethod, obj));
    
    lFields = asList(d.honorFieldOrder ? fieldObjectsInFieldOrder(c, fields) : fields);

    // Render this$0/this$1 first because unstructure needs it for constructor call.
    
    int n = l(lFields);
    for (int i = 0; i < n; i++) {
      Field f = lFields.get(i);
      if (f.getName().startsWith("this$")) {
        lFields.remove(i);
        lFields.add(0, f);
        break;
      }
    }
  
    
    d.setFields(info, lFields);
  } // << if (lFields == null)

  // get _persistenceInfo from field and/or dynamic field
  IF1<Object, Map> piGetter = d.persistenceInfo.get(c);
  Map persistenceInfo = piGetter == null ? null : piGetter.get(o);
  
  if (piGetter == null && o instanceof DynamicObject)
    persistenceInfo = (Map) getOptDynOnly(((DynamicObject) o), "_persistenceInfo");

  
  LinkedHashMap<String, Object> fv = new LinkedHashMap();
  Object defaultInstance = info.emptyInstance;
  if (!referencable)
    throw fail("Not referencable: " + className(o));
    
  for (Field f : lFields) {
    Object value, defaultValue = null;
    try {
      value = f.get(o);
      defaultValue = defaultInstance == null ? null : f.get(defaultInstance);
    } catch (Exception e) {
      value = "?";
    }
      
    if (!eq(defaultValue, value) && (persistenceInfo == null
      || !Boolean.FALSE.equals(persistenceInfo.get(f.getName()))))
      fv.put(f.getName(), value);
      
    
  }
  
  String shortName = info.shortName;
    
  // Now we have fields & values. Process fieldValues if it's a DynamicObject.
  
  Object classNameFromFV = fv.get("className");
  
  // omit field "className" if equal to class's name
  if (concept && eq(classNameFromFV, shortName))
    fv.remove("className");
          
  if (o instanceof DynamicObject) {
    putAll(fv, (Map) fv.get("fieldValues"));
    fv.remove("fieldValues");
    if (((DynamicObject) o).className != null) {
      // TODO: this probably doesn't work with inner classes
      
      shortName = shortDynClassNameForStructure((DynamicObject) o);
      fv.remove("className");
      
      // special handling for missing Class objects encoded as DynamicObject
      if (eq(shortName, "java.lang.Class")) {
        d.append("class(");
        d.append(quoted(fv.get("name")));
        d.append(")");
        return;
      }
    }
  }
  
  d.writeObject(o, shortName, fv);
} catch (Exception __e) { throw rethrow(__e); } }



// An "Android" is a program that accepts text questions (on console or TCP) and outputs one response text per question

//please include function myJavaSource. // for getting my known commands

static boolean makeAndroid3_disable = false; // disable all android making

static class Android3 implements AutoCloseable {
  String greeting;
  boolean publicOverride = false; // optionally set this in client
  int startPort = 5000; // optionally set this in client
  IResponder responder;
  boolean console = true;
  boolean quiet = false; // no messages on console
  boolean daemon = false;
  boolean incomingSilent = false;
  int incomingPrintLimit = 200;
  boolean useMultiPort = true;
  boolean recordHistory = false;
  boolean verbose = false;
  int answerPrintLimit = 500;
  boolean newLineAboveAnswer, newLineBelowAnswer;
  
  // set by system
  int port;
  long vport;
  IDialogHandler handler;
  ServerSocket server;
  
  Android3(String greeting) {
  this.greeting = greeting;}
  Android3() {}
  
  public void close() { dispose(); }
  
  synchronized void dispose() {
    if (server != null) {
      try {
        server.close();
      } catch (IOException e) {
        print("[internal] " + e);
      }
      server = null;
    }
    if (vport != 0) { try {
      print("Disposing " + this);
      removeFromMultiPort(vport);
      vport = 0;
    } catch (Throwable __e) { pcallFail(__e); }}
  }
  
  public String toString() {
    return "Bot: " + greeting + " [port " + port + (vport == 0 ? "" : ", vport " + vport) + "]";
  }
}

static abstract class Responder implements IResponder {}

interface IResponder {
  String answer(String s, List<String> history);
}

static Android3 makeAndroid3(final String greeting) {
  return makeAndroid3(new Android3(greeting));
}

static Android3 makeAndroid3(final String greeting, Responder responder) {
  Android3 android = new Android3(greeting);
  android.responder = responder;
  return makeAndroid3(android);
}

static Android3 makeAndroid3(final Android3 a) {
  if (makeAndroid3_disable) return a;
  
  if (a.responder == null)
    a.responder = new Responder() {
      public String answer(String s, List<String> history) {
        return callStaticAnswerMethod(s, history);
      }
    };
    
  if (!a.quiet)
    print("[bot] " + a.greeting);
  
  if (a.console && (readLine_noReadLine || makeAndroid3_consoleInUse()))
    a.console = false;
  
  record(a);
  
  if (a.useMultiPort)
    a.vport = addToMultiPort(a.greeting,
      makeAndroid3_verboseResponder(a));
      
  if (a.console)
    makeAndroid3_handleConsole(a);

  if (a.useMultiPort) return a;

  a.handler = makeAndroid3_makeDialogHandler(a);
  if (a.quiet) startDialogServer_quiet.set(true);
  try {
    a.port = a.daemon
      ? startDialogServerOnPortAboveDaemon(a.startPort, a.handler)
      : startDialogServerOnPortAbove(a.startPort, a.handler);
  } finally {
    startDialogServer_quiet.set(null);
  }
  a.server = startDialogServer_serverSocket;

  return a;
}

static void makeAndroid3_handleConsole(final Android3 a) {
  // Console handling stuff
  if (!a.quiet)
    print("You may also type on this console.");
  { startThread(new Runnable() {  public void run() { try {  List<String> history = new ArrayList();
    while (licensed()) {
      String line;
      try {
        line = readLine();
      } catch (Throwable e) {
        print(getInnerMessage(e));
        break;
      }
      if (line == null) break;
      /*if (eq(line, "bye")) {
        print("> bye stranger");
        history = new ArrayList<S>();
      } else*/ {
        history.add(line);
        history.add(makeAndroid3_getAnswer(line, history, a)); // prints answer on console too
      }
    }
  
} catch (Exception __e) { throw rethrow(__e); } }  public String toString() { return "List<String> history = new ArrayList();\r\n    while (licensed()) {\r\n      Stri..."; }}); }
}

static DialogHandler makeAndroid3_makeDialogHandler(final Android3 a) {
  return new DialogHandler() {
public void run(final DialogIO io) {
    if (!a.publicOverride && !(publicCommOn() || io.isLocalConnection())) {
      io.sendLine("Sorry, not allowed");
      return;
    }
    
    String dialogID = randomID(8);
    
    io.sendLine(a.greeting + " / Your ID: " + dialogID);
    
    List<String> history = new ArrayList();
    
    while (io.isStillConnected()) {
      if (io.waitForLine()) {
        final String line = io.readLineNoBlock();
        String s = dialogID + " at " + now() + ": " + quote(line);
        if (!a.incomingSilent)
          print(shorten(s, a.incomingPrintLimit));
        if (eq(line, "bye")) {
          io.sendLine("bye stranger");
          return;
        }
        Matches m = new Matches();
        if (a.recordHistory)
          history.add(line);
        String answer;
        if (match3("this is a continuation of talk *", s, m)
          || match3("hello bot! this is a continuation of talk *", s, m)) {
          dialogID = unquote(m.m[0]);
          answer = "ok";
        } else try {
          makeAndroid3_io.set(io);
          answer = makeAndroid3_getAnswer(line, history, a);
        } finally {
          makeAndroid3_io.set(null);
        }
        if (a.recordHistory)
          history.add(answer);
        io.sendLine(answer);
        //appendToLog(logFile, s);
      }
    }
  }};
}

static String makeAndroid3_getAnswer(String line, List<String> history, Android3 a) {
  String answer, originalAnswer;
  try {
    originalAnswer = a.responder.answer(line, history);
    answer = makeAndroid3_fallback(line, history, originalAnswer);
  } catch (Throwable e) {
    e = getInnerException(e);
    printStackTrace(e);
    originalAnswer = answer = e.toString();
  }
  if (!a.incomingSilent) {
    if (originalAnswer == null) originalAnswer = "?";
    if (a.newLineAboveAnswer) print();
    print(">" + dropFirst(indentx(2, shorten(rtrim(originalAnswer), a.answerPrintLimit))));
    if (a.newLineBelowAnswer) print();
  }
  return answer;
}

static String makeAndroid3_fallback(String s, List<String> history, String answer) {
  // Now we only do the safe thing instead of VM inspection - give out our process ID
  if (answer == null && match3("what is your pid", s))
    return getPID();
    
  if (answer == null && match3("what is your program id", s)) // should be fairly safe, right?
    return getProgramID();
    
  if (match3("get injection id", s))
    return getInjectionID();
    
  if (answer == null) answer = "?";
  if (answer.indexOf('\n') >= 0 || answer.indexOf('\r') >= 0)
    answer = quote(answer);
  return answer;
}

static boolean makeAndroid3_consoleInUse() {
  if (isTrue(vm_generalMap_get("consoleInUse"))) return true;
  for (Object o : record_list)
    if (o instanceof Android3 && ((Android3) o).console)
      return true;
  return false;
}

static Responder makeAndroid3_verboseResponder(final Android3 a) {
  return new Responder() {
    public String answer(String s, List<String> history) {
      if (a.verbose)
        print("> " + shorten(s, a.incomingPrintLimit));
      String answer = a.responder.answer(s, history);
      if (a.verbose)
        print("< " + shorten(answer, a.incomingPrintLimit));
      return answer;
    }
  };
}

static ThreadLocal<DialogIO> makeAndroid3_io = new ThreadLocal();

static Android3 makeAndroid3() {
  return makeAndroid3(getProgramTitle() + ".");
}


static String makeResponder_callAnswerMethod(Object bot, String s, List<String> history) {
  String answer = (String) callOpt(bot, "answer", s, history);
  if (answer == null)
    answer = (String) callOpt(bot, "answer", s);
  return answer;
}

static Responder makeResponder(final Object bot) {
  if (bot instanceof Responder) return (Responder) bot;
  
  if (bot instanceof String) {
    String f =  (String) bot;
    return new Responder() {
      public String answer(String s, List<String> history) {
        String answer = (String) callOptMC((String) bot, s, history);
        if (answer == null)
          answer = (String) callOptMC((String) bot, s);
        return answer;
      }
    };
  }
  
  return new Responder() {
    public String answer(String s, List<String> history) {
      return makeResponder_callAnswerMethod(bot, s, history);
    }
  };
}


static String defaultBotName() {
  return getProgramTitle() + ".";
}


  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 <A, B> Map<A, B> syncMRUCache(int size) {
  return synchroMap(new MRUCache(size));
}


// f must return a list
static List concatMap(Object f, Iterable l) {
  return concatLists(map(f, l));
}

static List concatMap(Iterable l, Object f) {
  return concatMap(f, l);
}

static List concatMap(Object f, Object[] l) {
  return concatLists(map(f, l));
}

static List concatMap(Object[] l, Object f) {
  return concatMap(f, l);
}

static <A, B, C extends Iterable<B>> List<B> concatMap(Iterable<A> l, IF1<A, C> f) {
  return concatMap(l, (Object) f);
}

static <A, B, C extends Iterable<B>> List<B> concatMap(IF1<A, C> f, Iterable<A> l) {
  return concatMap(l, f);
}

static <A, B, C extends Iterable<B>> List<B> concatMap(IF1<A, C> f, A[] l) {
  return concatMap((Object) f, l);
}


static List<File> listFilesWithSuffix(File dir, String suffix) {
  List<File> l = new ArrayList();
  for (File f : listFiles(dir))
    if (!f.isDirectory() && (empty(suffix) || endsWithIgnoreCase(f.getName(), suffix)))
      l.add(f);
  return l;
}

static List<File> listFilesWithSuffix(String suffix, File dir) {
  return listFilesWithSuffix(dir, suffix);
}


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


static TreeSet<String> caseInsensitiveSet() {
  return caseInsensitiveSet_treeSet();
}

static TreeSet<String> caseInsensitiveSet(Collection<String> c) {
  return caseInsensitiveSet_treeSet(c);
}


static <A> TreeSet<A> treeSet() {
  return new TreeSet();
}


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


static 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 boolean rectContains(Rect a, Rect b) {
  return b.x >= a.x && b.y >= a.y && b.x2() <= a.x2() && b.y2() <= a.y2();
}

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

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

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


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


static boolean isTrueOrYes(Object o) {
  return isTrueOpt(o) || o instanceof String && (eqicOneOf(((String) o), "1", "t", "true") || isYes(((String) o)));
}


static <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 void setDynObjectValue(DynamicObject o, String field, Object value) {
  dynamicObject_setRawFieldValue(o, field, value);
}


static void metaMapPut(IMeta o, Object key, Object value) {
  { if (o != null) o.metaPut(key, value); }
}

static void metaMapPut(Object o, Object key, Object value) {
  var meta = initIMeta(o);
  { if (meta != null) meta.metaPut(key, value); }
}


// This is a bit rough... finds static and non-static methods.

static 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 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 void upgradeJavaXAndRestart() {
  
    run("#1001639");
    restart();
    sleep();
  
  
}


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


// BREAKING CHANGE!
// Also NOTE: Iterators of these sync-wrapped collections
// after generally NOT thread-safe!
// TODO: change that?
static <A> Set<A> synchroLinkedHashSet() {
  
  
  return synchronizedSet(new CompactLinkedHashSet());
  
}


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


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


static <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 <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 <A> HashSet<A> lithashset(A... items) {
  HashSet<A> set = new HashSet();
  for (A a : items) set.add(a);
  return set;
}


static Object dm_getStemByID(Object id) {
  return dm_callOS("getModuleByID", str(id));
}


static IF0<PingSource> ping_v3_pingSourceMaker_cache;
static 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 IF0<PingSource> ping_v3_pingSourceMaker_load() {
  return or((IF0) vm_generalMap_get("ping_v3_pingSourceMaker"), () -> null);
}





  static String format3(String pat, Object... args) {
    if (args.length == 0) return pat;
    
    List<String> tok = javaTokPlusPeriod(pat);
    int argidx = 0;
    for (int i = 1; i < tok.size(); i += 2)
      if (tok.get(i).equals("*"))
        tok.set(i, format3_formatArg(argidx < args.length ? args[argidx++] : "null"));
    return join(tok);
  }
  
  static String format3_formatArg(Object arg) {
    if (arg == null) return "null";
    if (arg instanceof String) {
      String s = (String) arg;
      return isIdentifier(s) || isNonNegativeInteger(s) ? s : quote(s);
    }
    if (arg instanceof Integer || arg instanceof Long) return String.valueOf(arg);
    return quote(structure(arg));
  }
  



static boolean isLocalhost(String ip) {
  return isLoopbackIP(ip) || eqic(ip, "localhost");
}


static int vmPort() {
  return myVMPort();
}


static DialogIO talkToThisVM() {
  return new talkToThisVM_IO();
}

static class talkToThisVM_IO extends DialogIO { 
  List<String> answers = ll(thisVMGreeting());
  
  boolean isLocalConnection() { return true; }
  boolean isStillConnected() { return true; }
  int getPort() { return vmPort(); }
  
  void sendLine(String line) {
    answers.add(or2(sendToThisVM_newThread(line), "?"));
  }
  
  String readLineImpl() { try {
    return popFirst(answers);
  } catch (Exception __e) { throw rethrow(__e); } }
  
  public void close() {}
  Socket getSocket() { return null; }
}


static int indexOfIgnoreCase_manual(String a, String b) {
  return indexOfIgnoreCase_manual(a, b, 0);
}

static int indexOfIgnoreCase_manual(String a, String b, int i) {
  int la = strL(a), lb = strL(b);
  if (la < lb) return -1;
  int n = la-lb;
  
  loop: for (; i <= n; i++) {
    for (int j = 0; j < lb; j++) {
      char c1 = a.charAt(i+j), c2 = b.charAt(j);
      if (!eqic(c1, c2))
        continue loop;
    }
    return i;
  }
  return -1;
}


static Producer<String> javaTokC_noMLS_iterator(final String s) {
  return javaTokC_noMLS_iterator(s, 0);
}

static Producer<String> javaTokC_noMLS_iterator(final String s, final int startIndex) {
  return new Producer<String>() {
    final int l = s.length();
    int i = startIndex;
    
    public String next() {
      if (i >= l) return null;
      
      int j = i;
      char c, d;
      
      // scan for whitespace
      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);
  
      // scan for non-whitespace
      if (c == '\'' || c == '"') {
        char opener = c;
        ++j;
        while (j < l) {
          if (s.charAt(j) == opener || s.charAt(j) == '\n') { // end at \n to not propagate unclosed string literal errors
            ++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; // Long constants like 1L
      } else
        ++j;
        
      String t = quickSubstring(s, i, j);
      i = j;
      return t;
    }
  };
}



static Producer<String> javaTokC_noMLS_onReader(final BufferedReader r) {
  final class X implements Producer<String> {
    StringBuilder buf = new StringBuilder(); // stores from "i"
    char c, d, e = 'x'; // just not '\0'
    
    X() {
      // fill c, d and e
      nc();
      nc();
      nc();
    }
    
    // get next character(s) into c, d and e
    void nc() { try {
      c = d;
      d = e;
      if (e == '\0') return;
      int i = r.read();
      e = i < 0 ? '\0'
        : i == '\0' ? '_' // shouldn't happen anymore
        : (char) i;
    } catch (Exception __e) { throw rethrow(__e); } }
    
    void ncSave() {
      if (c != '\0') {
        buf.append(c);
        nc();
      }
    }
    
    public String next() {
      // scan for whitespace
      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;

      // scan for non-whitespace
      if (c == '\'' || c == '"') {
        char opener = c;
        ncSave();
        while (c != '\0') {
          if (c == opener || c == '\n') { // end at \n to not propagate unclosed string literal errors
            ncSave();
            break;
          } else if (c == '\\') {
            ncSave();
            ncSave();
          } else
            ncSave();
        }
      } else if (Character.isJavaIdentifierStart(c))
        do ncSave(); while (Character.isJavaIdentifierPart(c) || c == '\''); // for stuff like "don't"
      else if (Character.isDigit(c)) {
        do ncSave(); while (Character.isDigit(c));
        if (c == 'L') ncSave(); // Long constants like 1L
      } else
        ncSave();
        
      String t = buf.toString();
      buf.setLength(0);
      return t;
    }
  }
  
  return new X();
}



static String actualMCDollar() {
  return actualMC().getName() + "$";
}


static BigInteger parseBigInt(String s) {
  return new BigInteger(s);
}


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


static float parseFloat(String s) {
  return Float.parseFloat(s);
}


static String trivialUnquote(String s) {
  return dropPrefixSuffix("\"", s);
}


static short[] shortArrayFromBytes(byte[] a) {
  return shortArrayFromBytes(a, 0, l(a));
}

static short[] shortArrayFromBytes(byte[] a, int from, int to) {
  short[] b = new short[(to-from)/2];
  for (int i = 0; i < b.length; i++)
    b[i] = shortFromBytes(a, from+i*2);
  return b;
}


static 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 long[] longArrayFromBytes(byte[] a) {
  return longArrayFromBytes(a, 0, l(a));
}

static long[] longArrayFromBytes(byte[] a, int from, int to) {
  long[] b = new long[(to-from)/8];
  for (int i = 0; i < b.length; i++)
    b[i] = longFromBytes_bigEndian(a, from+i*8);
  return b;
}


static 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); // fallback
      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);
          // Octal escape?
          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;
          // Hex Unicode: u????
          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; // added by Stefan
          }
          i++;
        }
        buf[n++] = ch;
      }
      return new String(buf, 0, n);
    }
  }
    
  return s; // not quoted - return original
}


static 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 String internIfLongerThan(String s, int l) {
  return s == null ? null : l(s) >= l ? intern(s) : s;
}


static 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);
    }
  }
  return unquoteSingleOrDoubleQuotes(s);
}


static 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 boolean isLongConstant(String s) {
  if (!s.endsWith("L")) return false;
  s = s.substring(0, l(s)-1);
  return isInteger(s);
}


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

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


static boolean warn_on = true;
static ThreadLocal<List<String>> warn_warnings = new ThreadLocal();

static void warn(String s) {
  if (warn_on)
    print("Warning: " + s);
}

static void warn(String s, List<String> warnings) {
  warn(s);
  if (warnings != null)
    warnings.add(s);
  addToCollection(warn_warnings.get(), s);
}


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


static <A> TreeMap<String, A> ciMap() {
  return caseInsensitiveMap();
}


static List parseList(String s) {
  return (List) safeUnstructure(s);
}


static <A> List<A> synchroLinkedList() {
  return synchroList(new LinkedList<A>());
}



static <A, B> NavigableMap<A, B> synchroNavigableMap(NavigableMap<A, B> map) {
  
  
    return Collections.synchronizedNavigableMap(map);
  
}


static <A, B> SortedMap<A, B> synchroSortedMap(SortedMap<A, B> map) {
  
  
    return Collections.synchronizedSortedMap(map);
  
}


static 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 boolean isAbstract(Class c) {
  return (c.getModifiers() & Modifier.ABSTRACT) != 0;
}

static boolean isAbstract(Method m) {
  return (m.getModifiers() & Modifier.ABSTRACT) != 0;
}


static <A> Constructor nuStubInnerObject_findConstructor(Class<A> c) { return nuStubInnerObject_findConstructor(c, null); }
static <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 Map<Class, Constructor> nuEmptyObject_cache = newDangerousWeakHashMap();

static <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 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 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) { pcallFail(__e); }}
}


static 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 void setOptAll_pcall(Object o, Object... values) {
  //values = expandParams(c.getClass(), 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 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 void pcallOpt_noArgs(Object o, String method) {
  try { callOpt_noArgs(o, method); } catch (Throwable __e) { pcallFail(__e); }
}


  static RuntimeException todo() {
    throw new RuntimeException("TODO");
  }
  
  static RuntimeException todo(Object msg) {
    throw new RuntimeException("TODO: " + msg);
  }


static Object newMultiDimensionalOuterArray(Class elementType, int dimensions, int length) {
  int[] dims = new int[dimensions];
  dims[0] = length;
  return Array.newInstance(elementType, dims);
}


static 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 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 double[] toDoubleArray(float... l) {
    double[] a = new double[l(l)];
    for (int i = 0; i < a.length; i++)
      a[i] = l[i];
    return a;
  }


  static double[] toDoubleArray(int... l) {
    double[] a = new double[l(l)];
    for (int i = 0; i < a.length; i++)
      a[i] = l[i];
    return a;
  }






static float[] toFloatArray(List<Float> l) {
  float[] a = new float[l(l)];
  for (int i = 0; i < a.length; i++)
    a[i] = l.get(i);
  return a;
}

static float[] toFloatArray(double[] l) {
  float[] a = new float[l(l)];
  for (int i = 0; i < a.length; i++)
    a[i] = (float) l[i];
  return a;
}


static 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 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 TreeSet<String> ciSet() {
  return caseInsensitiveSet();
}


// DIFFERENCES to jfind: always ignores case, doesn't recognize <id> etc
// You probably want jmatch2

static boolean jmatch(String pat, String s) {
  return jmatch(pat, s, null);
}

static boolean jmatch(String pat, String s, Matches matches) {
  if (s == null) return false;
  return jmatch(pat, javaTok(s), matches);
}

static boolean jmatch(String pat, List<String> toks) {
  return jmatch(pat, toks, null);
}

static boolean jmatch(String pat, List<String> toks, Matches matches) {
  List<String> tokpat = javaTok(pat);
  String[] m = match2(tokpat, toks);
  //print(structure(tokpat) + " on " + structure(toks) + " => " + structure(m));
  if (m == null)
    return false;
  else {
    if (matches != null) matches.m = m;
    return true;
  }
}


static <A> AutoCloseable tempSetTL(ThreadLocal<A> tl, A a) {
  return tempSetThreadLocal(tl, a);
}


static <A> AutoCloseable tempSetTL(BetterThreadLocal<A> tl, A a) {
  return tempSetThreadLocalIfNecessary(tl, a);
}



static ThreadLocal<Boolean> DynamicObject_loading = or((ThreadLocal) get(getClass("x30_pkg.x30_util"), "DynamicObject_loading"), new ThreadLocal());

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


static Map<String, Integer> newFindBot2_cache = synchroHashMap();
static boolean newFindBot2_verbose = false;

static DialogIO newFindBot2(String name) {
  Integer port = newFindBot2_cache.get(name);
  if (port != null) {
    if (newFindBot2_verbose)
      print("newFindBot2: testing " + name + " => " + port);
    DialogIO io = talkTo(port);
    String q = format("has bot *", name);
    String s = io.ask(q);
    if (match("yes", s)) {
      io = talkToSubBot(name, io);
      call(io, "pushback", "?"); // put some hello string in (yes, this should be improved.)
      return io;
    }
    // bot not there anymore - remove cache entry
    newFindBot2_cache.remove(name);
    if (newFindBot2_verbose)
      print("newFindBot2: dropping " + name + " => " + port);
  }
  
  DialogIO io = findBot(name);
  if (io != null) {
    newFindBot2_cache.put(name, io.getPort());
    if (newFindBot2_verbose)
      print("newFindBot2: remembering " + name + " => " + port);
  }
  return io;
}


static Throwable getInnerException(Throwable e) {
  if (e == null) return null;
  while (e.getCause() != null)
    e = e.getCause();
  return e;
}

static Throwable getInnerException(Runnable r) {
  return getInnerException(getException(r));
}


static String baseClassName(String className) {
  return substring(className, className.lastIndexOf('.')+1);
}

static String baseClassName(Object o) {
  return baseClassName(getClassName(o));
}


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


static List<String> parse3(String s) {
  return dropPunctuation(javaTokPlusPeriod(s));
}


static boolean equalsIgnoreCase(String a, String b) {
  return eqic(a, b);
}

static boolean equalsIgnoreCase(char a, char b) {
  return eqic(a, b);
}


static void assertFalse(Object o) {
  if (!(eq(o, false) /*|| isFalse(pcallF(o))*/))
    throw fail(str(o));
}
  
static boolean assertFalse(boolean b) {
  if (b) throw fail("oops");
  return b;
}

static boolean assertFalse(String msg, boolean b) {
  if (b) throw fail(msg);
  return b;
}



static boolean isDigit(char c) {
  return Character.isDigit(c);
}


static boolean match3(String pat, String s) {
  return match3(pat, s, null);
}

static boolean match3(String pat, String s, Matches matches) {
  if (pat == null || s == null) return false;
  return match3(pat, parse3_cachedInput(s), matches);
}
  
static boolean match3(String pat, List<String> toks, Matches matches) {
  List<String> tokpat = parse3_cachedPattern(pat);
  return match3(tokpat, toks, matches);
}

static boolean match3(List<String> tokpat, List<String> toks, Matches matches) {
  String[] m = match2(tokpat, toks);
  //print(structure(tokpat) + " on " + structure(toks) + " => " + structure(m));
  if (m == null) return false;
  if (matches != null) matches.m = m; return true;
}


static <A> A assertEquals(Object x, A y) {
  return assertEquals("", x, y);
}

static <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 void assertEquals(Scorer scorer, Object x, Object y) {
    assertEquals(scorer, "", x, y);
  }
  
  static void assertEquals(Scorer scorer, String msg, Object x, Object y) {
    if (scorer == null) { assertEquals(msg, x, y); return; }
    scorer.add(eq(x, y), nullIfEmpty(msg));
  }



static 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;
    
    // scan for whitespace
    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);

    // scan for non-whitespace
    if (c == '\'' || c == '"') {
      char opener = c;
      ++j;
      while (j < l) {
        if (s.charAt(j) == opener || s.charAt(j) == '\n') { // end at \n to not propagate unclosed string literal errors
          ++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)); // for stuff like "don't"
    else if (Character.isDigit(c)) {
      do ++j; while (j < l && Character.isDigit(s.charAt(j)));
      if (j < l && s.charAt(j) == 'L') ++j; // Long constants like 1L
    } 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 String commaCombine(Object... l) {
  return joinNemptiesWithComma(flattenCollectionsAndArrays(l));
}


static String stringIf(boolean b, String s) {
  return stringIfTrue(b, s);
}

static String stringIf(String s, boolean b) {
  return stringIf(b, s);
}


static boolean isJavaXClassName(String s) { return isJavaXClassName(s, "main$"); }
static boolean isJavaXClassName(String s, String mcDollar) {
  return startsWithOneOf(s, mcDollar, "main$", "loadableUtils.", "x30");
}


static void quoteToPrintWriter(String s, PrintWriter out) {
  if (s == null) { out.print("null"); return; }
  out.print('"');
  int l = s.length();
  for (int i = 0; i < l; i++) {
    char c = s.charAt(i);
    if (c == '\\' || c == '"') {
      out.print('\\'); out.print(c);
    } else if (c == '\r')
      out.print("\\r");
    else if (c == '\n')
      out.print("\\n");
    else if (c == '\0')
      out.print("\\0");
    else
      out.print(c);
  }
  out.print('"');
}


static boolean isSubClassOf(Class a, Class b) {
  return isSubclass(a, b);
}


static boolean isSyntheticOrAnonymous(Class c) {
  return c != null && (c.isSynthetic() || isAnonymousClassName(c.getName()));
}


// keeps package names for dynamic code (package dyn.*)
static String shortDynClassNameForStructure(Object o) {
   if (o instanceof DynamicObject && ((DynamicObject) o).className != null)
    return ((DynamicObject) o).className;
  if (o == null) return null;
  Class c = o instanceof Class ? (Class) o : o.getClass();
  String name = c.getName();
  return name.startsWith("dyn.") ? classNameToVM(name) : shortenClassName(name);
}


static boolean isPersistableClass(Class c) {
  String name = c.getName();
  if (isSubtypeOf(c, TransientObject.class)) return false;
  if (isAnonymousClassName(name)) return false;
  if (isBoxedType(c)) return true;
  if (isArrayType(c)) return true;
  if (c == Class.class || c == String.class || c == File.class || c == Color.class) return true;
  if (name.startsWith("java.util.Collections$Synchronized")) return true;
  
  if (hasThisDollarFields(c))
    return hasSingleArgumentConstructor(c);
  else
    return getDefaultConstructor(c) != null;
}


static <A> A last(List<A> l) {
  return empty(l) ? null : l.get(l.size()-1);
}

static char last(String s) {
  return empty(s) ? '#' : s.charAt(l(s)-1);
}

static byte last(byte[] a) {
  return l(a) != 0 ? a[l(a)-1] : 0;
}


  static int last(int[] a) {
    return l(a) != 0 ? a[l(a)-1] : 0;
  }


  static long last(long[] a) {
    return l(a) != 0 ? a[l(a)-1] : 0;
  }



static double last(double[] a) {
  return l(a) != 0 ? a[l(a)-1] : 0;
}

static <A> A last(A[] a) {
  return l(a) != 0 ? a[l(a)-1] : null;
}

static <A> A last(Iterator<A> it) {
  A a = null;
  while  (it.hasNext()) { ping(); a = it.next(); }
  return a;
}

static <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 <A> A last(SortedSet<A> l) {
  return l == null ? null : l.last();
}


static <A> A last(ReverseChain<A> l) {
  return l == null ? null : l.element;
}



















static <A> A last(CompactLinkedHashSet<A> set) {
  return set == null ? null : set.last();
}



static Constructor getDefaultConstructor(Class c) {
  if (c != null)
    for (Constructor m : getDeclaredConstructors_cached(c))
      if (empty(m.getParameterTypes()))
        return m;
  return null;
}


static Object invokeConstructor(Constructor m, Object... args) { try {
  makeAccessible(m);
  return m.newInstance(args);
} catch (Exception __e) { throw rethrow(__e); } }


static int countDots(String s) {
  int n = l(s), count = 0;
  for (int i = 0; i < n; i++) if (s.charAt(i) == '.') ++count;
  return count;
}


static boolean isCIMap_gen(Map map) {
  return map instanceof TreeMap && className(((TreeMap) map).comparator()).contains("CIComp");
}


// works for both java.util-wrapped maps as well as our own
static <A, B> Map<A, B> unwrapSynchronizedMap(Map<A, B> map) {
  if (eqOneOf(shortClassName(map),
    "SynchronizedMap",
    "SynchronizedSortedMap",
    "SynchronizedNavigableMap"))
    return (Map) get_raw(map, "m");
  return map;
}


static <A, B> Map<A, B> cloneMap(Map<A, B> map) {
  if (map == null) return new HashMap();
  // assume mutex is equal to map
  synchronized(map) {
    return map instanceof TreeMap ? new TreeMap((TreeMap) map) // copies comparator
      : map instanceof LinkedHashMap ? new LinkedHashMap(map)
      : new HashMap(map);
  }
}

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


// Use like this: renderVars(+x, +y)
// Or like this: renderVars SomeID(+x, +y)
static String renderVars(Object... params) {
  return renderVars_str(params);
}


static boolean isCISet_gen(Iterable<String> l) {
  return l instanceof TreeSet && className(((TreeSet) l).comparator()).contains("CIComp");
}


static <A> List<A> unwrapSynchronizedList(List<A> l) {
  
  if (eqOneOf(className(l),
    "java.util.Collections$SynchronizedList",
    "java.util.Collections$SynchronizedRandomAccessList"))
    return (List) get_raw(l, "list");
  return l;
}


static String quoteCharacter(char c) {
  if (c == '\'') return "'\\''";
  if (c == '\\') return "'\\\\'";
  if (c == '\r') return "'\\r'";
  if (c == '\n') return "'\\n'";
  if (c == '\t') return "'\\t'";
  return "'" + c + "'";
}



  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 String boolArrayToHex(boolean[] a) {
  return bytesToHex(boolArrayToBytes(a));
}


static String shortArrayToHex_bigEndian(short[] a) {
  return bytesToHex(byteArrayFromShorts_bigEndian(a));
}


static String longArrayToHex_bigEndian(long[] a) {
  return bytesToHex(byteArrayFromLongs_bigEndian(a));
}


static Pair<Class, Integer> arrayTypeAndDimensions(Object o) {
  return arrayTypeAndDimensions(_getClass(o));
}

static Pair<Class, Integer> arrayTypeAndDimensions(Class c) {
  if (c == null || !c.isArray()) return null;
  Class elem = c.getComponentType();
  if (elem.isArray())
    return mapPairB(arrayTypeAndDimensions(elem), dim -> dim+1);
  return pair(elem, 1);
}


static int stdcompare(Number a, Number b) {
  return cmp(a, b);
}

static int stdcompare(String a, String b) {
  return cmp(a, b);
}

static int stdcompare(long a, long b) {
  return a < b ? -1 : a > b ? 1 : 0;
}

static int stdcompare(Object a, Object b) {
  return cmp(a, b);
}



static Map<Class, Field[]> getDeclaredFields_cache = newDangerousWeakHashMap();

static Field[] getDeclaredFields_cached(Class c) {
  Field[] fields;
  synchronized(getDeclaredFields_cache) {
    fields = getDeclaredFields_cache.get(c);
    if (fields == null) {
      getDeclaredFields_cache.put(c, fields = c.getDeclaredFields());
      for (Field f : fields)
        makeAccessible(f);
    }
  }
  return fields;
}


static Object fieldGet(Field f, Object o) { try {
  return f == null ? null : f.get(o);
} catch (Exception __e) { throw rethrow(__e); } }


static Method findInstanceMethod(Class c, String method, Object... args) {
  while (c != null) {
    for (Method m : c.getDeclaredMethods())
      if (m.getName().equals(method) && findMethod_checkArgs(m, args, false))
        return m;
    c = c.getSuperclass();
  }
  return null;
}



static Set<Field> fieldObjectsInFieldOrder(Class c, Set<Field> fields) {
  try {
    var byName = mapToKey(f -> f.getName(), fields);
    LinkedHashSet<Field> out = new LinkedHashSet();
    for (String name : unnullForIteration(getFieldOrder(c))) {
      Field f = byName.get(name);
      if (f != null) {
        byName.remove(name);
        out.add(f);
      }
    }
    addAll(out, fields);
    return out;
  } catch (Throwable __0) { printStackTrace(__0);
    return fields;
  }
}


static <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 <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 <A, B> Map<A, B> putAll(Map<A, B> a, Object... b) {
  if (a != null)
    litmap_impl(a, b);
  return a;
}



static String quoted(Object o) {
  return quote(o);
}



static String quoted(String s) {
  return quote(s);
}


static void removeFromMultiPort(long vport) {
  if (vport == 0) return;
  for (Object port : getMultiPorts())
    call(port, "removePort", vport);
}


static String callStaticAnswerMethod(List bots, String s) {
  for (Object c : bots) try {
    String answer = callStaticAnswerMethod(c, s);
    if (!empty(answer)) return answer;
  } catch (Throwable e) {
    print("Error calling " + getProgramID(c));
    e.printStackTrace();
  }
  return null;
}

static String callStaticAnswerMethod(Object c, String s) {
  String answer = (String) callOpt(c, "answer", s, litlist(s));
  if (answer == null)
    answer = (String) callOpt(c, "answer", s);
  return emptyToNull(answer);
}

static String callStaticAnswerMethod(String s) {
  return callStaticAnswerMethod(mc(), s);
}

static String callStaticAnswerMethod(String s, List<String> history) {
  return callStaticAnswerMethod(mc(), s, history);
}

static String callStaticAnswerMethod(Object c, String s, List<String> history) {
  String answer = (String) callOpt(c, "answer", s, history);
  if (answer == null)
    answer = (String) callOpt(c, "answer", s);
  return emptyToNull(answer);
}


static List<Object> record_list = synchroList();

static void record(Object o) {
  record_list.add(o);
}


static Object addToMultiPort_responder;

static long addToMultiPort(final String botName) {
  return addToMultiPort(botName, new Object() {
    public String answer(String s, List<String> history) {
      String answer =  (String) (callOpt(getMainClass(), "answer", s, history));
      if (answer != null) return answer;
      answer = (String) callOpt(getMainClass(), "answer", s);
      if (answer != null) return answer;
      if (match3("get injection id", s))
        return getInjectionID();
      return null;
    }
  });
}

static long addToMultiPort(final String botName, final Object responder) {
  //print(botName);
  addToMultiPort_responder = responder;
  startMultiPort();
  List ports = getMultiPorts();
  if (ports == null) return 0;
  if (ports.isEmpty())
    throw fail("No multiports!");
  if (ports.size() > 1)
    print("Multiple multi-ports. Using last one.");
  Object port = last(ports);
  Object responder2 = new Object() {
    public String answer(String s, List<String> history) {
      if (match3("get injection id", s))
        return getInjectionID();
      if (match3("your name", s))
        return botName;
      return (String) call(responder, "answer", s, history);
    }
  };
  record(responder2);
  return (Long) call(port, "addResponder", botName, responder2);
}



static AtomicInteger dialogServer_clients = new AtomicInteger();
static boolean dialogServer_printConnects = false;
static ThreadLocal<Boolean> startDialogServer_quiet = new ThreadLocal();

static Set<String> dialogServer_knownClients = synchroTreeSet();

static int startDialogServerOnPortAbove(int port, IDialogHandler handler) {
  while (!forbiddenPort(port) && !startDialogServerIfPortAvailable(port, handler))
    ++port;
  return port;
}

static int startDialogServerOnPortAboveDaemon(int port, IDialogHandler handler) {
  while (!forbiddenPort(port) && !startDialogServerIfPortAvailable(port, handler, true))
    ++port;
  return port;
}

static void startDialogServer(int port, IDialogHandler handler) {
  if (!startDialogServerIfPortAvailable(port, handler))
    throw fail("Can't start dialog server on port " + port);
}

static boolean startDialogServerIfPortAvailable(int port, final IDialogHandler handler) {
  return startDialogServerIfPortAvailable(port, handler, false);
}

static ServerSocket startDialogServer_serverSocket;
  
static boolean startDialogServerIfPortAvailable(int port, final IDialogHandler handler, boolean daemon) {
  ServerSocket serverSocket = null;
  try {
    serverSocket = new ServerSocket(port);
  } catch (IOException e) {
    // probably the port number is used - let's assume there already is a chat server.
    return false;
  }
  final ServerSocket _serverSocket = serverSocket;
  startDialogServer_serverSocket = serverSocket;

  Thread thread = new Thread("Socket accept port " + port) { public void run() {
   try {
    while (true) {
      try {
        final Socket s = _serverSocket.accept();
        
        String client = s.getInetAddress().toString();
        if (!dialogServer_knownClients.contains(client) && neq(client, "/127.0.0.1")) {
          print("connect from " + client + " - clients: " + dialogServer_clients.incrementAndGet());
          dialogServer_knownClients.add(client);
        }
        
        String threadName = "Handling client " + s.getInetAddress();

        Thread t2 = new Thread(threadName) {
         public void run() {
          try {
            final Writer w = new OutputStreamWriter(s.getOutputStream(), "UTF-8");
            final BufferedReader in = new BufferedReader(
              new InputStreamReader(s.getInputStream(), "UTF-8"));
              
            DialogIO io = new DialogIO() {
            
              // This should be the same as #1001076 (talkTo)
            
  boolean isLocalConnection() {
    return s.getInetAddress().isLoopbackAddress();
  }
  
  boolean isStillConnected() {
    return !(eos || s.isClosed());
  }
  
  void sendLine(String line) { try {
    w.write(line + "\n");
    w.flush();
  } catch (Exception __e) { throw rethrow(__e); } }
  
  String readLineImpl() { try {
    return in.readLine();
  } catch (Exception __e) { throw rethrow(__e); } }
  
  public void close() {
    try {
      s.close();
    } catch (IOException e) {
      // whatever
    }
  }
  
  Socket getSocket() {
    return s;
  }
  };
            
            try {
              handler.run(io);
            } finally {
              if (!io.noClose)
                s.close();
            }
          } catch (IOException e) {
            print("[internal] " + e);
          } finally {
            //print("client disconnect - " + dialogServer_clients.decrementAndGet() + " remaining");
          }
         }
        }; // Thread t2
        t2.setDaemon(true); // ?
        t2.start();
      } catch (SocketTimeoutException e) {
      }
    }   
   } catch (IOException e) {
     print("[internal] " + e);
   }
  }};
  if (daemon) thread.setDaemon(true);
  thread.start();
 
  if (!isTrue(getAndClearThreadLocal(startDialogServer_quiet)))
    print("Dialog server on port " + port + " started."); 
  return true;
}


static volatile boolean readLine_noReadLine = false;

static String readLine_lastInput;
static String readLine_prefix = "[] ";

static String readLine() {
  if (readLine_noReadLine) return null;
  String s = readLineHidden();
  if (s != null) {
    readLine_lastInput = s;
    print(readLine_prefix + s);
  }
  return s;
}


static String getInnerMessage(Throwable e) {
  if (e == null) return null;
  return getInnerException(e).getMessage();
}


static boolean publicCommOn() {
  return "1".equals(loadTextFile(new File(userHome(), ".javax/public-communication")));
}


static int randomID_defaultLength = 12;

static String randomID(int length) {
  return makeRandomID(length);
}

static String randomID(Random r, int length) {
  return makeRandomID(r, length);
}

static String randomID() {
  return randomID(randomID_defaultLength);
}

static String randomID(Random r) {
  return randomID(r, randomID_defaultLength);
}


static String indentx(Object s) {
  return indentx(strOrEmpty(s));
}

static String indentx(String s) {
  return indentx(indent_default, s);
}

static String indentx(int n, String s) {
  return dropSuffix(repeat(' ', n), indent(n, s));
}

static String indentx(String indent, String s) {
  return dropSuffix(indent, indent(indent, s));
}


static String processID_cached;

// try to get our current process ID
static String getPID() {
  if (processID_cached == null) {
    String name = ManagementFactory.getRuntimeMXBean().getName();
    processID_cached = name.replaceAll("@.*", "");
  }
  return processID_cached;
}


static String getInjectionID() {
  return (String) call(getJavaX(), "getInjectionID", getMainClass());
}


static String getProgramTitle() {
  return getProgramName();
}


static Object callOptMC(String method, Object... args) {
  return callOpt(mc(), method, args);
}


static 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 <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 <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 File[] listFiles(File dir) {
  File[] files = dir == null ? null : dir.listFiles();
  return files == null ? new File[0] : files;
}

static File[] listFiles(String dir) {
  return listFiles(new File(dir));
}


static TreeSet<String> caseInsensitiveSet_treeSet() {
  return new TreeSet(caseInsensitiveComparator());
}

static TreeSet<String> caseInsensitiveSet_treeSet(Collection<String> c) {
  return toCaseInsensitiveSet_treeSet(c);
}




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

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



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


static boolean isTrueOpt(Object o) {
  if (o instanceof Boolean)
    return ((Boolean) o).booleanValue();
  return false;
}

static boolean isTrueOpt(String field, Object o) {
  return isTrueOpt(getOpt(field, o));
}


static boolean eqicOneOf(String s, String... l) {
  for (String x : l) if (eqic(s, x)) return true; return false;
}


static List<String> isYes_yesses = litlist("y", "yes", "yeah", "y", "yup", "yo", "corect", "sure", "ok", "afirmative"); // << collapsed words, so "corect" means "correct"

static boolean isYes(String s) {
  return isYes_yesses.contains(collapseWord(toLowerCase(firstWord2(s))));
}


static IMeta initIMeta(Object o) {
  if (o == null) return null;
  if (o instanceof IMeta) return ((IMeta) o);
  if (o instanceof JComponent) return initMetaOfJComponent((JComponent) o);
  
  // This is not really used. Try to use BufferedImageWithMeta instead
  if (o instanceof BufferedImage) return optCast(IMeta.class, ((BufferedImage) o).getProperty("meta"));
  return null;
}


static Class run(String progID, String... args) {
  Class main = hotwire(progID);
  
  callMain(main, args);
  return main;
}


static void restart() {
  Object j = getJavaX();
  call(j, "cleanRestart", get(j, "fullArgs"));
}


static volatile boolean sleep_noSleep = false;

static void sleep(long ms) {
  ping();
  if (ms < 0) return;
  // allow spin locks
  if (isAWTThread() && ms > 100) throw fail("Should not sleep on AWT thread");
  try {
    Thread.sleep(ms);
  } catch (Exception e) { throw new RuntimeException(e); }
}

static void sleep() { try {
  if (sleep_noSleep) throw fail("nosleep");
  print("Sleeping.");
  sleepQuietly();
} catch (Exception __e) { throw rethrow(__e); } }


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

static <A> List<A> cloneSubList(List<A> l, int startIndex) {
  return newSubList(l, startIndex);
}


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

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




// This is made for NL parsing.
// It's javaTok extended with "..." token, "$n" and "#n" and
// special quotes (which are converted to normal ones).

static List<String> javaTokPlusPeriod(String s) {
  List<String> tok = new ArrayList<String>();
  if (s == null) return tok;
  int l = s.length();
  
  int i = 0;
  while (i < l) {
    int j = i;
    char c; String cc;
    
    // scan for whitespace
    while (j < l) {
      c = s.charAt(j);
      cc = s.substring(j, Math.min(j+2, l));
      if (c == ' ' || c == '\t' || c == '\r' || c == '\n')
        ++j;
      else if (cc.equals("/*")) {
        do ++j; while (j < l && !s.substring(j, Math.min(j+2, l)).equals("*/"));
        j = Math.min(j+2, l);
      } else if (cc.equals("//")) {
        do ++j; while (j < l && "\r\n".indexOf(s.charAt(j)) < 0);
      } else
        break;
    }
    
    tok.add(s.substring(i, j));
    i = j;
    if (i >= l) break;
    c = s.charAt(i);
    cc = s.substring(i, Math.min(i+2, l));

    // scan for non-whitespace
    if (c == (char) 0x201C || c == (char) 0x201D) c = '"'; // normalize quotes
    if (c == '\'' || c == '"') {
      char opener = c;
      ++j;
      while (j < l) {
        char _c = s.charAt(j);
        if (_c == (char) 0x201C || _c == (char) 0x201D) _c = '"'; // normalize quotes
        if (_c == opener) {
          ++j;
          break;
        } else if (s.charAt(j) == '\\' && j+1 < l)
          j += 2;
        else
          ++j;
      }
      if (j-1 >= i+1) {
        tok.add(opener + s.substring(i+1, j-1) + opener);
        i = j;
        continue;
      }
    } else if (Character.isJavaIdentifierStart(c))
      do ++j; while (j < l && (Character.isJavaIdentifierPart(s.charAt(j)) || s.charAt(j) == '\'')); // for things like "this one's"
    else if (Character.isDigit(c))
      do ++j; while (j < l && Character.isDigit(s.charAt(j)));
    else if (cc.equals("[[")) {
      do ++j; while (j+1 < l && !s.substring(j, j+2).equals("]]"));
      j = Math.min(j+2, l);
    } else if (cc.equals("[=") && 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 if (s.substring(j, Math.min(j+3, l)).equals("..."))
      j += 3;
    else if (c == '$' || c == '#')
      do ++j; while (j < l && Character.isDigit(s.charAt(j)));
    else
      ++j;

    tok.add(s.substring(i, j));
    i = j;
  }
  
  if ((tok.size() % 2) == 0) tok.add("");
  return tok;
}



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


static boolean isLoopbackIP(String ip) {
  return eq(ip, "127.0.0.1");
}


static int myVMPort() {
  List records =  (List) (get(getJavaX(), "record_list"));
  Object android = last(records);
  return or0((Integer) get(android, "port"));
}


static String thisVMGreeting() {
  List record_list =  (List) (get(getJavaX(), "record_list"));
  Object android = first(record_list); // Should be of class Android3
  return getString(android, "greeting");
}


static String or2(String a, String b) {
  return nempty(a) ? a : b;
}

static String or2(String a, String b, String c) {
  return or2(or2(a, b), c);
}


static String sendToThisVM_newThread(String s, Object... args) {
  final String _s = format(s, args);
  try {
    return (String) evalInNewThread(new F0<Object>() { public Object get() { try { 
      return callStaticAnswerMethod(getJavaX(), _s);
     } catch (Exception __e) { throw rethrow(__e); } }
  public String toString() { return "return callStaticAnswerMethod(getJavaX(), _s);"; }});
  } catch (Throwable e) {
    e = getInnerException(e);
    printStackTrace(e);
    return str(e);
  }
}


static <A> A popFirst(List<A> l) {
  if (empty(l)) return null;
  A a = first(l);
  l.remove(0);
  return a;
}

static <A> A popFirst(Collection<A> l) {
  if (empty(l)) return null;
  A a = first(l);
  l.remove(a);
  return a;
}

static <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 <A> List<A> popFirst(int n, List<A> l) {
  List<A> part = cloneSubList(l, 0, n);
  removeSubList(l, 0, n);
  return part;
}

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


static String quickSubstring(String s, int i, int j) {
  if (i >= j) return "";
  return s.substring(i, j);
}


static Class actualMC() {
  return or((Class) realMC(), mc());
}


static String dropPrefixSuffix(String prefix, String s) { return dropPrefixSuffix(prefix, prefix, s); }
static String dropPrefixSuffix(String prefix, String suffix, String s) {
  return dropPrefix(prefix, dropSuffix(suffix, s));
}


static short shortFromBytes(byte[] a, int i) {
  return (short) (ubyteToInt(a[i]) << 8
    | ubyteToInt(a[i+1]));
}


static 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 long longFromBytes_bigEndian(byte[] a, int i) {
  return twoIntsToLong_bigEndian(
    intFromBytes_bigEndian(a, i),
    intFromBytes_bigEndian(a, i+4));
}


static String unquoteSingleOrDoubleQuotes(String s) {
  if (s == null) return null;
  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);
          // Octal escape?
          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;
          // Hex Unicode: u????
          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; // added by Stefan
          }
          i++;
        }
        sb.append(ch);
      }
      return sb.toString();
    }
  }
    
  return s; // not quoted - return original
}


static <A> boolean addToCollection(Collection<A> c, A a) {
  return c != null && c.add(a);
}


static <A> TreeMap<String, A> caseInsensitiveMap() {
  return new TreeMap(caseInsensitiveComparator());
}


static Object safeUnstructure(String s) {
  return unstructure(s, true);
}

static Object safeUnstructure(File f) {
  return safeUnstructureGZFile(f);
}


static Class getOuterClass(Class c) { return getOuterClass(c, null); }
static 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 Class getOuterClass(Object o) { return getOuterClass(o, null); }
static Class getOuterClass(Object o, Object classFinder) {
  return getOuterClass(_getClass(o), classFinder);
}


static HashMap<String, Field> instanceFieldsMap(Object o) {
  return (HashMap) getOpt_getFieldMap(o);
}





static Map<Class, Field[]> thisDollarOneFields_cache = newDangerousWeakHashMap();

static 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 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 Map<Class, HashMap<String, Method>> callOpt_noArgs_cache = newDangerousWeakHashMap();

static Object callOpt_noArgs(Object o, String method) { try {
  if (o == null) return null;
  if (o instanceof Class)
    return callOpt(o, method); // not optimized
  
  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); } }

// used internally - we are in synchronized block
static 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;
}


// TODO: extended multi-line strings

static int javaTok_n, javaTok_elements;
static boolean javaTok_opt = false;

static 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;
    
        // scan for whitespace
        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);
    
        // scan for non-whitespace
        
        // Special JavaX syntax: 'identifier
        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 == '\'') { // allow multi-line strings, but not for '
              ++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) == '\'')); // for stuff like "don't"
        else if (Character.isDigit(c)) {
          do ++j; while (j < l && Character.isDigit(s.charAt(j)));
          if (j < l && s.charAt(j) == 'L') ++j; // Long constants like 1L
        } 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 List<String> javaTok(List<String> tok) {
  return javaTokWithExisting(join(tok), tok);
}


static <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 <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 Class<?> getClass(String name) {
  return _getClass(name);
}

static Class getClass(Object o) {
  return _getClass(o);
}

static Class getClass(Object realm, String name) {
  return _getClass(realm, name);
}


static Throwable getException(Runnable r) {
  try {
    callF(r);
    return null;
  } catch (Throwable e) {
    return e;
  }
}


static List<String> dropPunctuation_keep = ll("*", "<", ">");

static List<String> dropPunctuation(List<String> tok) {
  tok = new ArrayList<String>(tok);
  for (int i = 1; i < tok.size(); i += 2) {
    String t = tok.get(i);
    if (t.length() == 1 && !Character.isLetter(t.charAt(0)) && !Character.isDigit(t.charAt(0)) && !dropPunctuation_keep.contains(t)) {
      tok.set(i-1, tok.get(i-1) + tok.get(i+1));
      tok.remove(i);
      tok.remove(i);
      i -= 2;
    }
  }
  return tok;
}

static String dropPunctuation(String s) {
  return join(dropPunctuation(nlTok(s)));
}


static ThreadLocal<Boolean> assertVerbose_value = new ThreadLocal();

static void assertVerbose(boolean b) {
  assertVerbose_value.set(b);
}

static boolean assertVerbose() { return isTrue(assertVerbose_value.get()); }


static <A> A assertEqualsVerbose(Object x, A y) {
  assertEqualsVerbose((String) null, x, y);
  return y;
}

// x = expected, y = actual
static <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) + ": " + /*sfu*/(x));
  return y;
}


static void assertEqualsVerbose(Scorer scorer, Object x, Object y) { assertEqualsVerbose(scorer, "", x, y); }
static void assertEqualsVerbose(Scorer scorer, String msg, Object x, Object y) {
  if (scorer == null) { assertEqualsVerbose(x, y); return; }
  if (!eq(x, y)) {
    print(appendColonIfNempty(msg) + y + " != " + x);
    scorer.add(false);
  } else {
    print("OK: " + appendColonIfNempty(msg) + x);
    scorer.add(true);
  }
}



static String nullIfEmpty(String s) {
  return isEmpty(s) ? null : s;
}

static <A, B> Map<A, B> nullIfEmpty(Map<A, B> map) {
  return isEmpty(map) ? null : map;
}

static <A> List<A> nullIfEmpty(List<A> l) {
  return isEmpty(l) ? null : l;
}


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


static String joinNemptiesWithComma(Object... strings) {
  return joinNempties(", ", strings);
}

static String joinNemptiesWithComma(Iterable strings) {
  return joinNempties(", ", strings);
}


static 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 List flattenCollectionsAndArrays(Object... whatever) {
  return flattenCollectionsAndArrays(ll(whatever));
}


static String stringIfTrue(boolean b, String s) {
  return b ? s : "";
}


static boolean isSubclass(Class a, Class b) {
  return a != null && b != null && b.isAssignableFrom(a);
}


static boolean isBoxedType(Class type) {
  return type == Boolean.class
    || type == Integer.class
    || type == Long.class
    || type == Float.class
    || type == Short.class
    || type == Character.class
    || type == Byte.class
    || type == Double.class;
}


static boolean isArrayType(Class type) {
  return type != null && type.isArray();
}


static boolean hasThisDollarFields(Object o) {
  Matches m = new Matches();
  for (var f : allFieldObjects_dontMakeAccessible(o))
    if (startsWith(f.getName(), "this$", m) && isInteger(m.rest()))
      return true;
  return false;
}


static boolean hasSingleArgumentConstructor(Class c) {
  if (c != null)
    for (Constructor m : getDeclaredConstructors_cached(c))
      if (l(m.getParameterTypes()) == 1)
        return true;
  return false;
}


static byte[] boolArrayToBytes(boolean[] a) {
  byte[] b = new byte[(l(a)+7)/8];
  for (int i = 0; i < l(a); i++)
    if (a[i])
      b[i/8] |= 1 << (i & 7);
  return b;
}


static byte[] byteArrayFromShorts_bigEndian(short[] a) {
  return byteArrayFromShorts_bigEndian(a, 0, l(a));
}

static byte[] byteArrayFromShorts_bigEndian(short[] a, int from, int to) {
  byte[] b = new byte[(to-from)*2];
  for (int i = 0; i < a.length; i++) {
    short s = a[from+i];
    b[i*2] = (byte) (s >> 8);
    b[i*2+1] = (byte) s;
  }
  return b;
}


static byte[] byteArrayFromLongs_bigEndian(long[] a) {
  return byteArrayFromLongs_bigEndian(a, 0, l(a));
}

static byte[] byteArrayFromLongs_bigEndian(long[] a, int from, int to) {
  byte[] b = new byte[(to-from)*8];
  for (int i = 0; i < a.length; i++) {
    long s = a[from+i];
    b[i*8] = (byte) (s >> 56);
    b[i*8+1] = (byte) (s >> 48);
    b[i*8+2] = (byte) (s >> 40);
    b[i*8+3] = (byte) (s >> 32);
    b[i*8+4] = (byte) (s >> 24);
    b[i*8+5] = (byte) (s >> 16);
    b[i*8+6] = (byte) (s >> 8);
    b[i*8+7] = (byte) s;
  }
  return b;
}


static <A, B, C> List<Pair<A, C>> mapPairB(final Object f, Iterable<Pair<A, B>> l) {
  return map(l, new F1<Pair<A, B>, Pair<A, C>>() { public Pair<A, C> get(Pair<A, B> p) { try { 
    return p == null ? null : pair(p.a, (C) callF(f, p.b));
   } catch (Exception __e) { throw rethrow(__e); } }
  public String toString() { return "p == null ? null : pair(p.a, (C) callF(f, p.b))"; }});
}

static <A, B, C> List<Pair<A, C>> mapPairB(final F1<B, C> f, Iterable<Pair<A, B>> l) {
  return mapPairB((Object) f, l);
}

static <A, B, C> List<Pair<A, C>> mapPairB(final IF1<B, C> f, Iterable<Pair<A, B>> l) {
  return mapPairB((Object) f, l);
}

static <A, B, C> List<Pair<A, C>> mapPairB(Iterable<Pair<A, B>> l, IF1<B, C> f) {
  return mapPairB((Object) f, l);
}

static <A, B, C> Pair<A, C> mapPairB(IF1<B, C> f, Pair<A, B> p) {
  return pairMapB(f, p);
}

static <A, B, C> Pair<A, C> mapPairB(Pair<A, B> p, IF1<B, C> f) {
  return pairMapB(f, p);
}


static Method findMethod(Object o, String method, Object... args) {
  return findMethod_cached(o, method, args);
}

static 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 <A, B> Map<B, A> mapToKey(Iterable<A> l, IF1<A, B> f) {
  return mapToKeys(l, f);
}



static <A, B> Map<B, A> mapToKey(IF1<A, B> f, Iterable<A> l) {
  return mapToKeys(f, l);
}


static Map<Class, List<String>> getFieldOrder_cache = weakMap();

static List<String> getFieldOrder(Object o) {
  return getFieldOrder(_getClass(o));
}

static List<String> getFieldOrder(Class c) {
  if (c == null) return null;
  return getOrCreate(getFieldOrder_cache, c,
    () -> splitAtSpace(toStringOpt(getOpt(c, "_fieldOrder"))));
}


static <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 <A, B extends A> boolean addAll(Collection<A> c, Collection<B> b) {
  return c != null && b != null && c.addAll(b);
}

static <A, B extends A> boolean addAll(Collection<A> c, B... b) {
  return c != null && b != null && c.addAll(Arrays.asList(b));
}



static <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 <A extends Container> A addAll(A c, Collection<? extends Component> components) {
  return addComponents(c, components);
}

static <A extends Container> A addAll(A c, Component... components) {
  return addComponents(c, components);
}


static List<Object> getMultiPorts() {
  return (List) callOpt(getJavaX(), "getMultiPorts");
}


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


static String emptyToNull(String s) {
  return eq(s, "") ? null : s;
}

static <A, B> Map<A, B> emptyToNull(Map<A, B> map) {
  return empty(map) ? null : map;
}


// start multi-port if none exists in current VM.
static void startMultiPort() {
  List mp = getMultiPorts();
  if (mp != null && mp.isEmpty()) {
    nohupJavax("#1001639");
    throw fail("Upgrading JavaX, please restart this program afterwards.");
    //callMain(hotwire("#1001672"));
  }
}


static <A> Set<A> synchroTreeSet() {
  return Collections.synchronizedSet(new TreeSet<A>());
}

static <A> Set<A> synchroTreeSet(TreeSet<A> set) {
  return Collections.synchronizedSet(set);
}


static boolean forbiddenPort(int port) {
  return port == 5037; // adb
}



static String readLineHidden() { try {
  if (get(javax(), "readLine_reader") == null)
    set(javax(), "readLine_reader" , new BufferedReader(new InputStreamReader(System.in, "UTF-8")));
  try {
    return ((BufferedReader) get(javax(), "readLine_reader")).readLine();
  } finally {
    consoleClearInput();
  }
} catch (Exception __e) { throw rethrow(__e); } }


static String loadTextFile(String fileName) {
  return loadTextFile(fileName, null);
}

static String loadTextFile(File f, String defaultContents) { return loadTextFile(f, defaultContents, "UTF-8"); }
static 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 String loadTextFile(String fileName, String defaultContents) {
  return fileName == null ? defaultContents : loadTextFile(newFile(fileName), defaultContents);
}

static 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 String makeRandomID(int length) {
  return makeRandomID(length, defaultRandomGenerator());
}

static 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 String makeRandomID(Random r, int length) {
  return makeRandomID(length, r);
}


static 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 <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 <A> List<A> repeat(int n, A a) {
  return repeat(a, n);
}


static int indent_default = 2;

static String indent(int indent) {
  return repeat(' ', indent);
}

static String indent(int indent, String s) {
  return indent(repeat(' ', indent), s);
}

static String indent(String indent, String s) {
  return indent + replace(unnull(s), "\n", "\n" + indent);
}

static String indent(String s) {
  return indent(indent_default, s);
}

static 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 String getProgramName_cache;

static String getProgramName() {
  Lock __0 = downloadLock(); lock(__0); try {
  if (getProgramName_cache == null)
    getProgramName_cache = getSnippetTitleOpt(programID());
  return getProgramName_cache;
} finally { unlock(__0); } }

static void _onLoad_getProgramName() {
  { startThread(new Runnable() {  public void run() { try {  getProgramName(); 
} catch (Exception __e) { throw rethrow(__e); } }  public String toString() { return "getProgramName();"; }}); }
}


static Comparator<String> caseInsensitiveComparator() {
  
  
  return betterCIComparator();
  
}


static TreeSet<String> toCaseInsensitiveSet_treeSet(Iterable<String> c) {
  if (isCISet(c)) return (TreeSet) c;
  TreeSet<String> set = caseInsensitiveSet_treeSet();
  addAll(set, c);
  return set;
}

static TreeSet<String> toCaseInsensitiveSet_treeSet(String... x) {
  TreeSet<String> set = caseInsensitiveSet_treeSet();
  addAll(set, x);
  return set;
}


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


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



static 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 List<String> toLowerCase(List<String> strings) {
  List<String> x = new ArrayList();
  for (String s : strings)
    x.add(s.toLowerCase());
  return x;
}

static 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 String toLowerCase(String s) {
  return s == null ? "" : s.toLowerCase();
}


static String firstWord2(String s) {
  s = xltrim(s);
  if (empty(s)) return "";
  if (isLetterOrDigit(first(s)))
    return takeCharsWhile(__37 -> isLetterOrDigit(__37), s);
  else return "" + first(s);
}


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


// custom mainClass only works with hotwire_here
static Class<?> hotwire(String src) { return hotwire(src, __1 -> mainClassNameForClassLoader(__1)); }
static Class<?> hotwire(String src, IF1<ClassLoader, String> calculateMainClass) {
  assertFalse(_inCore());
  Class j = getJavaX();
  if (isAndroid()) {
    synchronized(j) { // hopefully this goes well...
      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 <A> A callMain(A c, String... args) {
  callOpt(c, "main", new Object[] {args});
  return c;
}

static void callMain() {
  callMain(mc());
}


static Object sleepQuietly_monitor = new Object();

static void sleepQuietly() { try {
  assertFalse(isAWTThread());
  synchronized(sleepQuietly_monitor) { sleepQuietly_monitor.wait(); }
} catch (Exception __e) { throw rethrow(__e); } }


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

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




static int or0(Integer i) { return i == null ? 0 : i; }
static long or0(Long l) { return l == null ? 0L : l; }
static double or0(Double d) { return d == null ? 0.0 : d; }


static Object evalInNewThread(final Object f) {
  final Flag flag = new Flag();
  final Var var = new Var();
  final Var<Throwable> exception = new Var();
  { startThread(new Runnable() {  public void run() { try {  try {
      var.set(callF(f));
    } catch (Throwable e) {
      exception.set(e);
    }
    flag.raise();
  
} catch (Exception __e) { throw rethrow(__e); } }  public String toString() { return "try {\r\n      var.set(callF(f));\r\n    } catch (Throwable e) {\r\n      exception..."; }}); }
  flag.waitUntilUp();
  if (exception.has()) throw rethrow(exception.get());
  return var.get();
}


static Object realMC() {
  return getThreadLocal(realMC_tl());
}


static int ubyteToInt(byte b) {
  return b & 0x0FF;
}

static int ubyteToInt(char c) {
  return c & 0x0FF;
}


static int charDiff(char a, char b) {
  return (int) a-(int) b;
}

static int charDiff(String a, char b) {
  return charDiff(stringToChar(a), b);
}


static long twoIntsToLong_bigEndian(int a, int b) {
  return twoIntsToLong(a, b);
}


static int intFromBytes_bigEndian(byte[] a, int i) {
  return intFromBytes(a, i);
}


static 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 Object[] toArray(Collection c) {
  return toObjectArray(c);
}

static <A> A[] toArray(Class<A> type, Iterable<A> c) {
  return toArray(c, type);
}

static <A> A[] toArray(Class<A> type, Collection<A> c) {
  return toArray(c, type);
}

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

// array must have correct length and will be filled
static <A> A[] toArray(A[] array, Collection c) {
  if (array == null || c == null) return null;
  asList(c).toArray(array);
  return array;
}


static boolean reflection_isForbiddenMethod(Method m) {
  return m.getDeclaringClass() == Object.class
    && eqOneOf(m.getName(), "finalize", "clone", "registerNatives");
}


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

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


static 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 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;
    
    // scan for whitespace
    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);

    // scan for non-whitespace
    
    // Special JavaX syntax: 'identifier
    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 /*|| s.charAt(j) == '\n'*/) { // allow multi-line strings
          ++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)); // for stuff like "don't"
    else if (Character.isDigit(c)) {
      do ++j; while (j < l && Character.isDigit(s.charAt(j)));
      if (j < l && s.charAt(j) == 'L') ++j; // Long constants like 1L
    } 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 boolean javaTokWithExisting_isCopyable(String t, String s, int i, int j) {
  return t.length() == j-i
    && s.regionMatches(i, t, 0, j-i); // << could be left out, but that's brave
}


static List<String> nlTok(String s) {
  return javaTokPlusPeriod(s);
}


static String appendColonIfNempty(String s) {
  return empty(s) ? "" : s + ": ";
}


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

static boolean isEmpty(File f) {
  return f == null || f.length() == 0;
}

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

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

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




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


static boolean isEmpty(IntSize l) { return l == null || l.size() == 0; }


static String joinNempties(String sep, Object... strings) {
  return joinStrings(sep, strings);
}

static String joinNempties(String sep, Iterable strings) {
  return joinStrings(sep, strings);
}


static List<Field> allFieldObjects_dontMakeAccessible(Object o) {
  List<Field> fields = new ArrayList();
  Class _c = _getClass(o);
  do {
    addAll(fields, _c.getDeclaredFields());
    _c = _c.getSuperclass();
  } while (_c != null);
  return fields;
}


static Pair pairMapB(Object f, Pair p) {
  return p == null ? null : pair(p.a, callF(f, p.b));
}

static <A, B, C> Pair<A, C> pairMapB(IF1<B, C> f, Pair<A, B> p) {
  return p == null ? null : pair(p.a, f.get(p.b));
}

static Pair pairMapB(Pair p, Object f) {
  return pairMap(f, p);
}



static 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 <A, B> Map<B, A> mapToKeys(Iterable<A> l, IF1<A, B> f) {
  if (l == null) return null;
  HashMap<B, A> map = new HashMap();
  for (A a : l)
    map.put(f.get(a), a);
  return map;
}

static <A, B> Map<B, A> mapToKeys(IF1<A, B> f, A[] l) { return mapToKeys(f, asList(l)); }
static <A, B> Map<B, A> mapToKeys(IF1<A, B> f, Iterable<A> l) {
  return mapToKeys(l, f);
}


static <A, B> Map<A, B> weakMap() {
  return newWeakHashMap();
}


// allows null keys but not null values

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

// f : func -> B
static <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 <A, B> B getOrCreate(IF0<B> f, Map<A, B> map, A key) {
  return getOrCreate(map, key, f);
}

static <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 <A, B> B getOrCreate(Class<? extends B> c, Map<A, B> map, A key) {
  return getOrCreate(map, key, c);
}


static List<String> splitAtSpace(String s) {
  return empty(s) ? emptyList() : asList(s.split("\\s+"));
}


static String toStringOpt(Object o) {
  return o instanceof String ? ((String) o) : null;
}


static <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 <A extends Container> A addComponents(A c, Component... components) {
  return addComponents(c, asList(components));
}


static 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 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 <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 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 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 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 void set(BitSet bs, int idx) {
  { if (bs != null) bs.set(idx); }
}


static void consoleClearInput() {
  consoleSetInput("");
}


static ThreadLocal<VF1<File>> checkFileNotTooBigToRead_tl = new ThreadLocal();

static void checkFileNotTooBigToRead(File f) {
  callF(checkFileNotTooBigToRead_tl.get(), f);
}


static Random defaultRandomGenerator() {
  { Random r = customRandomizerForThisThread(); if (r != null) return r; }
  return ThreadLocalRandom.current();
}


static <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 <A> List<A> replace(A a, A b, List<A> l) {
  return replace(l, a, b);
}

// replace all occurrences of a in s with b
static String replace(String s, String a, String b) {
  return s == null ? null : a == null || b == null ? s : s.replace(a, b);
}

static String replace(String s, char a, char b) {
  return s == null ? null : s.replace(a, b);
}


static Lock downloadLock_lock = fairLock();

static Lock downloadLock() {
  return downloadLock_lock;
}


static String getSnippetTitleOpt(String s) {
  try {
    return isSnippetID(s) ? getSnippetTitle(s) : s;
  } catch (Throwable __e) { pcallFail(__e); }
  return s;
}


static betterCIComparator_C betterCIComparator_instance;

static betterCIComparator_C betterCIComparator() {
  if (betterCIComparator_instance == null)
    betterCIComparator_instance = new betterCIComparator_C();
  return betterCIComparator_instance;
}

final static 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) {
                    // No overflow because of numeric promotion
                    return c1 - c2;
                }
            }
        }
    }
    return n1 - n2;
  }
}


static boolean isCISet(Iterable<String> l) {
  return l instanceof TreeSet && ((TreeSet) l).comparator() == caseInsensitiveComparator();
}


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


// pred: char -> bool
static 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 String takeCharsWhile(IF1<Character, Boolean> f, String s) {
  return takeCharsWhile(s, f);
}


static boolean _inCore() {
  return false;
}


static List hotwire_copyOver_after = synchroList();

static void hotwire_copyOver(Class c) {
  // TODO: make a mechanism for making such "inheritable" fields
  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 ThreadLocal realMC_tl_tl = new ThreadLocal();

static ThreadLocal realMC_tl() {
  return realMC_tl_tl;
}


static char stringToChar(String s) {
  if (l(s) != 1) throw fail("bad stringToChar: " + s);
  return firstChar(s);
}


static long twoIntsToLong(int a, int b) {
  return (((long) a) << 32) | (((long) b) & 0xFFFFFFFFL);
}


static int intFromBytes(byte[] a, int i) {
  return ubyteToInt(a[i]) << 24
    | ubyteToInt(a[i+1]) << 16
    | ubyteToInt(a[i+2]) << 8
    | ubyteToInt(a[i+3]);
}


static boolean fileExists(String path) {
  return path != null && new File(path).exists();
}

static boolean fileExists(File f) {
  return f != null && f.exists();
}


static BufferedReader utf8BufferedReader(InputStream in) {
  return utf8bufferedReader(in);
}

static BufferedReader utf8BufferedReader(File f) {
  return utf8bufferedReader(f);
}


static int gzInputStream_defaultBufferSize = 65536;

static GZIPInputStream gzInputStream(File f) { try {
  return gzInputStream(new FileInputStream(f));
} catch (Exception __e) { throw rethrow(__e); } }

static GZIPInputStream gzInputStream(File f, int bufferSize) { try {
  return gzInputStream(new FileInputStream(f), bufferSize);
} catch (Exception __e) { throw rethrow(__e); } }

static GZIPInputStream gzInputStream(InputStream in) {
  return gzInputStream(in, gzInputStream_defaultBufferSize);
}

static GZIPInputStream gzInputStream(InputStream in, int bufferSize) { try {
  return _registerIOWrap(new GZIPInputStream(in, gzInputStream_defaultBufferSize), in);
} catch (Exception __e) { throw rethrow(__e); } }


static <A> A[] arrayOfType(Class<A> type, int n) {
  return makeArray(type, n);
}

static <A> A[] arrayOfType(int n, Class<A> type) {
  return arrayOfType(type, n);
}


static String joinStrings(String sep, Object... strings) {
  return joinStrings(sep, Arrays.asList(strings));
}

static 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 Pair pairMap(Object f, Pair p) {
  return p == null ? null : pair(callF(f, p.a), callF(f, p.b));
}

static <A> Pair<A, A> pairMap(IF1<A, A> f, Pair<A, A> p) {
  return p == null ? null : pair(callF(f, p.a), callF(f, p.b));
}

static Pair pairMap(Pair p, Object f) {
  return pairMap(f, p);
}



static Class hotwireOnce(String programID) {
  return hotwireCached(programID, false);
}


static void consoleSetInput(final String text) {
  
    if (headless()) return;
    setTextAndSelectAll(consoleInputField(), text);
    focusConsole();
  
}


static Random customRandomizerForThisThread() {
  return customRandomizerForThisThread_tl().get();
}


static 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 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 String getSnippetTitle(long id) {
  return getSnippetTitle(fsI(id));
}



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

static String substr(String s, int x, int y) {
  return substring(s, x, y);
}


static void setOptIfNotNull(Object o, String field, Object value) {
  if (value != null) setOpt(o, field, value);
}


static Object mainBot;

static Object getMainBot() {
  return mainBot;
}




static char firstChar(String s) {
  return s.charAt(0);
}


static BufferedReader utf8bufferedReader(InputStream in) { try {
  return in == null ? null : bufferedReader(_registerIOWrap(new InputStreamReader(in, "UTF-8"), in));
} catch (Exception __e) { throw rethrow(__e); } }

static BufferedReader utf8bufferedReader(File f) { try {
  return utf8bufferedReader(newFileInputStream(f));
} catch (Exception __e) { throw rethrow(__e); } }


static <A> A _registerIOWrap(A wrapper, Object wrapped) {
  return wrapper;
}


static <A> A[] makeArray(Class<A> type, int n) {
  return (A[]) Array.newInstance(type, n);
}


static TreeMap<String, Class> hotwireCached_cache = new TreeMap();
static Lock hotwireCached_lock = lock();

static Class hotwireCached(String programID) {
  return hotwireCached(programID, true);
}

static Class hotwireCached(String programID, boolean runMain) {
  return hotwireCached(programID, runMain, false);
}

static 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 boolean headless() {
  return isHeadless();
}


static JTextField setTextAndSelectAll(final JTextField tf, final String text) {
  if (tf != null) { swing(() -> { 
    tf.setText(text);
    tf.selectAll();
  }); }
  return tf;
}


static JTextField consoleInputField() {
  Object console = get(getJavaX(), "console");
  return (JTextField) getOpt(console, "tfInput");
}


static void focusConsole(String s) {
  setConsoleInput(s);
  focusConsole();
}

static void focusConsole() {
  JComponent tf = consoleInputFieldOrComboBox();
  if (tf != null) {
    //print("Focusing console");
    tf.requestFocus();
  }
}


static ThreadLocal<Random> customRandomizerForThisThread_tl = new ThreadLocal();

static ThreadLocal<Random> customRandomizerForThisThread_tl() {
  return customRandomizerForThisThread_tl;
}


static IResourceLoader vm_getResourceLoader() {
  return proxy(IResourceLoader.class, vm_generalMap_get("_officialResourceLoader"));
}


static boolean isLocalSnippetID(String snippetID) {
  return isSnippetID(snippetID) && isLocalSnippetID(psI(snippetID));
}

static boolean isLocalSnippetID(long snippetID) {
  return snippetID >= 1000 && snippetID <= 9999;
}


static 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 boolean isImageServerSnippet(long id) {
  return id >= 1100000 && id < 1200000;
}


static String imageServerURL() {
  return or2(trim(loadTextFile(javaxDataDir("image-server-url.txt"))), "http://botcompany.de/images/raw/");
}


static String muricaCredentialsQuery() {
  return htmlQuery(muricaCredentials());
}


static boolean isGeneralFileServerSnippet(long id) {
  return id >= 1400000 && id < 1500000;
}


static String tb_mainServer_default = "https://code.botcompany.de:9898";
static Object tb_mainServer_override; // func -> S

static String tb_mainServer() {
  if (tb_mainServer_override != null) return (String) callF(tb_mainServer_override);
  return trim(loadTextFile(tb_mainServer_file(),
    tb_mainServer_default));
}

static File tb_mainServer_file() {
  return getProgramFile("#1001638", "mainserver.txt");
}

static boolean tb_mainServer_isDefault() {
  return eq(tb_mainServer(), tb_mainServer_default);
}


static String standardCredentials_noCookies() {
  return standardCredentials() + "&noCookies=1";
}


static int loadPage_defaultTimeout = 60000;
static ThreadLocal<String> loadPage_charset = new ThreadLocal();
static boolean loadPage_allowGzip = true, loadPage_debug;
static boolean loadPage_anonymous = false; // don't send computer ID
static int loadPage_verboseness = 100000;
static int loadPage_retries = 1; //60; // seconds
static ThreadLocal<Boolean> loadPage_silent = new ThreadLocal();
static volatile int loadPage_forcedTimeout; // ms
static ThreadLocal<Integer> loadPage_forcedTimeout_byThread = new ThreadLocal(); // ms
static ThreadLocal<Map<String, List<String>>> loadPage_responseHeaders = new ThreadLocal();
static ThreadLocal<Map<String, String>> loadPage_extraHeaders = new ThreadLocal();
static 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 String loadPage_preprocess(String url) {  
  if (url.startsWith("tb/")) // don't think we use this anymore
    url = tb_mainServer() + "/" + url;
  if (url.indexOf("://") < 0)
    url = "http://" + url;
  return url;
}

static 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 String loadPage(URL url) {
  return loadPage(url.toExternalForm());
}

static String loadPage(URLConnection con, URL url) throws IOException {
  return loadPage(con, url, true);
}

static String loadPage(URLConnection con, URL url, boolean addHeaders) { try {
  Map<String, String> extraHeaders = getAndClearThreadLocal(loadPage_extraHeaders);
  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) {} // fails if within doPost
  
  return loadPage(con);
} catch (Exception __e) { throw rethrow(__e); } }

// just download as string, no shenanigans or extra headers or ANYTHING
static String loadPage(URLConnection con) { try {
  Long limit = optPar(loadPage_sizeLimit);
  URL url = con.getURL();
  
  
  vm_generalSubMap("URLConnection per thread").put(currentThread(), con);
  
  loadPage_responseHeaders.set(con.getHeaderFields());
  InputStream in = null;
  try {
    in = urlConnection_getInputStream(con);
  //vm_generalSubMap("InputStream per thread").put(currentThread(), in);
  if (loadPage_debug)
    print("Put stream in map: " + currentThread());
    String contentType = con.getContentType();
    if (contentType == null) {
      //printStruct("Headers: ", con.getHeaderFields());
      throw new IOException("Page could not be read: " + hideCredentials(url));
    }
    //print("Content-Type: " + contentType);
    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("InputStream per thread").remove(currentThread());
    
    vm_generalSubMap("URLConnection per thread").remove(currentThread());
    
    if (in != null) in.close();
  }
} catch (Exception __e) { throw rethrow(__e); } }

static 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);
  /* If Content-Type doesn't match this pre-conception, choose default and hope for the best. */
  //return or(match, "ISO-8859-1");
  return or(match, "UTF-8");
}

static 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 boolean saveTextFileIfChanged(File f, String contents) {
  return saveTextFileIfDifferent(f, contents);
}


static File snippetTitle_cacheFile(String snippetID) {
  return javaxCachesDir("Snippet Titles/" + psI(snippetID));
}


static String fsI(String id) {
  return formatSnippetID(id);
}

static String fsI(long id) {
  return formatSnippetID(id);
}




static BufferedReader bufferedReader(Reader r) { return bufferedReader(r, 8192); }
static BufferedReader bufferedReader(Reader r, int bufSize) {
  if (r == null) return null;
  return r instanceof BufferedReader ? (BufferedReader) r : _registerIOWrap(new BufferedReader(r, bufSize), r);
}

static BufferedReader bufferedReader(File f) {
  return utf8bufferedReader(f);
}


static FileInputStream newFileInputStream(File path) throws IOException {
  return newFileInputStream(path.getPath());
}

static FileInputStream newFileInputStream(String path) throws IOException {
  FileInputStream f = new FileInputStream(path);
  _registerIO(f, path, true);
  return f;
}


static Object makeDependent_postProcess;

static void makeDependent(Object c) {
  if (c == null) return;
  assertTrue("Not a class", c instanceof Class);
  dependentClasses(); // cleans up the list
  hotwire_classes.add(new WeakReference(c));
  
  Object local_log = getOpt(mc(), "local_log");
  if (local_log != null)
    setOpt(c, "local_log", local_log);
    
  /*if (isTrue(getOpt(c, 'ping_actions_shareable)))
    setOpt(c, +ping_actions);*/
    
  Object print_byThread = getOpt(mc(), "print_byThread");
  if (print_byThread != null)
    setOpt(c, "print_byThread", print_byThread);
    
  callF(makeDependent_postProcess, c);
}



static void setConsoleInput(String text) {
  consoleSetInput(text);
}


static JComponent consoleInputFieldOrComboBox() {
  Object console = get(getJavaX(), "console");
  JComboBox cb =  (JComboBox) (getOpt(console, "cbInput"));
  if (cb != null) return cb;
  return (JTextField) getOpt(console, "tfInput");
}


static <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 <A> A proxy(Object target, Class<A> intrface) {
  return proxy(intrface, target);
}


static long psI(String snippetID) {
  return parseSnippetID(snippetID);
}


static File localSnippetFile(long snippetID) {
  return localSnippetsDir(snippetID + ".text");
}

static File localSnippetFile(String snippetID) {
  return localSnippetFile(parseSnippetID(snippetID));
}


static String getFileInfoField(File f, String field) {
  return getOneLineFileInfoField(f, field);
}


static File dropExtension(File f) {
  return f == null ? null : fileInSameDir(f, dropExtension(f.getName()));
}

static String dropExtension(String s) {
  return takeFirst(s, smartLastIndexOf(s, '.'));
}


static String htmlQuery(Map params) {
  return empty(params) ? "" : "?" + makePostData(params);
}

static String htmlQuery(Object... data) {
  return empty(data) ? "" : "?" + makePostData(data);
}


static Object[] muricaCredentials() {
  String pass = muricaPassword();
  return nempty(pass) ? new Object[] {"_pass", pass } : new Object[0];
}


static File getProgramFile(String progID, String fileName) {
  if (new File(fileName).isAbsolute())
    return new File(fileName);
  return new File(getProgramDir(progID), fileName);
}

static File getProgramFile(String fileName) {
  return getProgramFile(getProgramID(), fileName);
}



static String standardCredentials() {
  String user = standardCredentialsUser();
  String pass = standardCredentialsPass();
  if (nempty(user) && nempty(pass))
    return "&_user=" + urlencode(user) + "&_pass=" + urlencode(pass);
  return "";
}


static boolean networkAllowanceTest(String url) {
  
  
  return isAllowed("networkAllowanceTest", url);
  
}


static void sleepSeconds(double s) {
  if (s > 0) sleep(round(s*1000));
}


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

static <A> A printWithTime(String s, A a) {
  print(hmsWithColons() + ": " + s, a);
  return a;
}


static 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) {
    //printShortException(e);
  }
  
}


static <A> A optPar(ThreadLocal<A> tl, A defaultValue) {
  A a = tl.get();
  if (a != null) {
    tl.set(null);
    return a;
  }
  return defaultValue;
}

static <A> A optPar(ThreadLocal<A> tl) {
  return optPar(tl, null);
}

static Object optPar(Object[] params, String name) {
  return optParam(params, name);
}

static Object optPar(String name, Object[] params) {
  return optParam(params, name);
}

static Object optPar(String name, Map params) {
  return optParam(name, params);
}

static <A> A optPar(Object[] params, String name, A defaultValue) {
  return optParam(params, name, defaultValue);
}

static <A> A optPar(String name, Object[] params, A defaultValue) {
  return optParam(params, name, defaultValue);
}


static 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 InputStream urlConnection_getInputStream(URLConnection con) throws IOException {
  return con.getInputStream();
}


static GZIPInputStream newGZIPInputStream(File f) {
  return gzInputStream(f);
}

static GZIPInputStream newGZIPInputStream(InputStream in) {
  return gzInputStream(in);
}


static String toHex(byte[] bytes) {
  return bytesToHex(bytes);
}

static String toHex(byte[] bytes, int ofs, int len) {
  return bytesToHex(bytes, ofs, len);
}



static byte[] utf8(String s) {
  return toUtf8(s);
}


static Matcher regexpMatcher(String pat, String s) {
  return compileRegexp(pat).matcher(unnull(s));
}

static Matcher regexpMatcher(java.util.regex.Pattern pat, String s) {
  return pat.matcher(unnull(s));
}


static URLConnection openConnection(String url) { try {
  return openConnection(new URL(url));
} catch (Exception __e) { throw rethrow(__e); } }

static URLConnection openConnection(URL url) { try {
  ping();
  
  callOpt(javax(), "recordOpenURLConnection", str(url));
  
  return url.openConnection();
} catch (Exception __e) { throw rethrow(__e); } }


static 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 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 boolean saveTextFileIfDifferent(File f, String contents) {
  if (eq(loadTextFile(f), contents)) return false; // TODO: optimize
  { saveTextFile(f, contents); return true; }
}


static File javaxCachesDir_dir; // can be set to work on different base dir

static File javaxCachesDir() {
  return javaxCachesDir_dir != null ? javaxCachesDir_dir : new File(userHome(), "JavaX-Caches");
}

static File javaxCachesDir(String sub) {
  return newFile(javaxCachesDir(), sub);
}




static void _registerIO(Object object, String path, boolean opened) {
}


static List<Class> dependentClasses() {
  return cleanUpAndGetWeakReferencesList(hotwire_classes);
}


static File localSnippetsDir() {
  return javaxDataDir("Personal Programs");
}

static File localSnippetsDir(String sub) {
  return newFile(localSnippetsDir(), sub);
}


static String getOneLineFileInfoField(File f, String field) {
  File infoFile = associatedInfosFile(f);
  List<String> lines = lines(loadTextFile(infoFile));
  return firstStartingWithIC_drop(lines, field + ": ");
}


static File fileInSameDir(File f, String newName) {
  return newFile(parentFile(f), newName);
}


static int smartLastIndexOf(String s, char c) {
  if (s == null) return 0;
  int i = s.lastIndexOf(c);
  return i >= 0 ? i : l(s);
}

static <A> int smartLastIndexOf(List<A> l, A sub) {
  int i = lastIndexOf(l, sub);
  return i < 0 ? l(l) : i;
}


static 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(/*escapeMultichars*/(value)));
    }
  }
  return str(buf);
}

static 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(/*escapeMultichars*/(value)));
    }
  }
  return str(buf);

}



static volatile boolean muricaPassword_pretendNotAuthed = false;

static String muricaPassword() {
  if (muricaPassword_pretendNotAuthed) return null;
  return trim(loadTextFile(muricaPasswordFile()));
}


static File getProgramDir() {
  return programDir();
}

static File getProgramDir(String snippetID) {
  return programDir(snippetID);
}


static String standardCredentialsUser() {
  return trim(loadTextFile(
    oneOfTheFiles(
      javaxSecretDir("tinybrain-username"),
      userDir(".tinybrain/username"))));
}


static String standardCredentialsPass() {
  return trim(loadTextFile(
    oneOfTheFiles(
      javaxSecretDir("tinybrain-userpass"),
      userDir(".tinybrain/userpass"))));
}


static String urlencode(String x) {
  try {
    return URLEncoder.encode(unnull(x), "UTF-8");
  } catch (UnsupportedEncodingException e) { throw new RuntimeException(e); }
}


static volatile Object isAllowed_function; // func(S, O[]) -> bool
static volatile boolean isAllowed_all = true;

static boolean isAllowed(String askingMethod, Object... args) {
  // check on VM level
  Object f = vm_generalMap_get("isAllowed_function");
  if (f != null && !isTrue(callF(f, askingMethod, args))) return false;
  
  // check locally
  return isAllowed_all || isTrue(callF(isAllowed_function, askingMethod, args));
}


static long round(double d) {
  return Math.round(d);
}

static String round(String s) {
  return roundBracket(s);
}


static Complex round(Complex c) {
  return new Complex(round(c.re), round(c.im));
}





static String hmsWithColons() {
  return hmsWithColons(now());
}

static String hmsWithColons(long time) {
  return new SimpleDateFormat("HH:mm:ss").format(time);
}



static String getComputerID_quick() {
  return computerID();
}


static <A> A optParam(ThreadLocal<A> tl, A defaultValue) {
  return optPar(tl, defaultValue);
}

static <A> A optParam(ThreadLocal<A> tl) {
  return optPar(tl);
}

static Object optParam(String name, Map params) {
  return mapGet(params, name);
}

// now also takes a map as single array entry
static <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 Object optParam(Object[] opt, String name) {
  return optParam(opt, name, null);
}

static Object optParam(String name, Object[] params) {
  return optParam(params, name);
}


static byte[] toUtf8(String s) { try {
  return s.getBytes(utf8charset());
} catch (Exception __e) { throw rethrow(__e); } }


/** writes safely (to temp file, then rename) */
static File saveTextFile(String fileName, String contents) throws IOException {
  /*ifdef CriticalActions
  temp beginCriticalAction("Saving file " + fileName + " (" + l(contents) + " chars)");
  endifdef*/
  
  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()); try {
    OutputStreamWriter outputStreamWriter = new OutputStreamWriter(fileOutputStream, "UTF-8");
    PrintWriter printWriter = new PrintWriter(outputStreamWriter);
    printWriter.print(contents);
    printWriter.close();
  } finally { _close(fileOutputStream); }}
  
  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 File saveTextFile(File fileName, String contents) { try {
  saveTextFile(fileName.getPath(), contents);
  return fileName;
} catch (Exception __e) { throw rethrow(__e); } }




static List<WeakReference<Class>> hotwire_classes = synchroList();

static Class<?> hotwireDependent(String src) {
  Class c = hotwire(src);
  makeDependent(c);
  return c;
}



static <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 File associatedInfosFile(File f) {
  return replaceExtension(f, ".infos");
}


static String lines(Iterable lines) { return fromLines(lines); }
static String lines(Object[] lines) { return fromLines(asList(lines)); }
static List<String> lines(String s) { return toLines(s); }

// convenience map call
static <A> String lines(Iterable<A> l, IF1<A, String> f) {
  return mapToLines(l, f);
}


static 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 String firstStartingWithIC_drop(String prefix, Collection<String> l) {
  return firstStartingWithIC_drop(l, prefix);
}


static File parentFile(File f) {
  return dirOfFile(f);
}


static Map<Object, Object> castMapToMapO(Map map) {
  return map;
}


static File muricaPasswordFile() {
  return new File(javaxSecretDir(), "murica/muricaPasswordFile");
}


static File oneOfTheFiles(String... paths) {
  if (paths != null) for (String path : paths)
    if (fileExists(path))
      return newFile(path);
  return null;
}

static File oneOfTheFiles(File... files) {
  return oneOfTheFiles(asList(files));
}

static File oneOfTheFiles(Iterable<File> files) {
  if (files != null) for (File f : files)
    if (fileExists(f))
      return f;
  return null;
}


static File javaxSecretDir_dir; // can be set to work on different base dir

static File javaxSecretDir() {
  return javaxSecretDir_dir != null ? javaxSecretDir_dir : new File(userHome(), "JavaX-Secret");
}

static File javaxSecretDir(String sub) {
  return newFile(javaxSecretDir(), sub);
}


static String roundBracket(String s) {
  return "(" + s + ")";
}

static String roundBracket(Object s) {
  return roundBracket(str(s));
}


static String _computerID;
static 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) {
      // legacy load
      _computerID = loadTextFile(userDir(".tinybrain/computer-id"));
      if (_computerID == null)
        _computerID = makeRandomID(12, new SecureRandom());
      saveTextFile(file, _computerID);
    }
  } finally { unlock(__0); } }
  return _computerID;
}


static boolean even(int i) {
  return (i & 1) == 0;
}

static boolean even(long i) {
  return (i & 1) == 0;
}

static boolean even(BigInteger n) {
  return even(n.intValue());
}




static Charset utf8charset_cache;
static Charset utf8charset() { if (utf8charset_cache == null) utf8charset_cache = utf8charset_load(); return utf8charset_cache;}

static Charset utf8charset_load() {
  return Charset.forName("UTF-8");
}


public static File mkdirsForFile(File file) {
  File dir = file.getParentFile();
  if (dir != null) { // is null if file is in current dir
    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 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 FileOutputStream newFileOutputStream(File path) throws IOException {
  return newFileOutputStream(path.getPath());
}

static FileOutputStream newFileOutputStream(String path) throws IOException {
  return newFileOutputStream(path, false);
}

static FileOutputStream newFileOutputStream(File path, boolean append) throws IOException {
  return newFileOutputStream(path.getPath(), append);
}

static FileOutputStream newFileOutputStream(String path, boolean append) throws IOException {
  mkdirsForFile(path);
  FileOutputStream f = new FileOutputStream(path, append);
  
  _registerIO(f, path, true);
  
  return f;
}




static File replaceExtension(File f, String extOld, String extNew) {
  return newFile(replaceExtension(f2s(f), extOld, extNew));
}

static File replaceExtension(File f, String extNew) {
  return replaceExtension(f, fileExtension(f), extNew);
}

static String replaceExtension(String s, String extOld, String extNew) {
  s = dropSuffixIC(addPrefixOptIfNempty(".", extOld), s);
  return s + addPrefixOptIfNempty(".", extNew);
}

static String replaceExtension(String name, String extNew) {
  return replaceExtension(name, fileExtension(name), extNew);
}


// usually L<S>
static 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 String fromLines(String... lines) {
  return fromLines(asList(lines));
}


static IterableIterator<String> toLines(File f) {
  return linesFromFile(f);
}

static 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 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 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 String mapToLines(Map map, Object f) {
  return lines(map(map, f));
}

static String mapToLines(Object f, Map map) {
  return lines(map(map, f));
}

static String mapToLines(Object f, Iterable l) {
  return lines(map(f, l));
}

static <A> String mapToLines(Iterable<A> l, IF1<A, String> f) {
  return mapToLines((Object) f, l);
}

static <A> String mapToLines(IF1<A, String> f, Iterable<A> l) {
  return mapToLines((Object) f, l);
}

static <A, B> String mapToLines(Map<A, B> map, IF2<A, B, String> f) {
  return lines(map(map, f));
}

static <A> String mapToLines(IF1<A, String> f, A data1, A... moreData) {
  return lines(map(f, data1, moreData));
}


static File dirOfFile(File f) {
  return f == null ? null : f.getParentFile();
}


static File computerIDFile() {
  return javaxDataDir("Basic Info/computer-id.txt");
}


static String f2s(File f) {
  return f == null ? null : f.getAbsolutePath();
}

static String f2s(String s) { return f2s(newFile(s)); }


 static String f2s(java.nio.file.Path p) {
  return p == null ? null : f2s(p.toFile());
}



static 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 String fileExtension(File f) {
  if (f == null) return null;
  return fileExtension(f.getName());
}

static String fileExtension(String s) {
  return substring(s, smartLastIndexOf(s, '.'));
}


static String dropSuffixIC(String suffix, String s) {
  return s == null ? null : ewic(s, suffix) ? s.substring(0, l(s)-l(suffix)) : s;
}


static String addPrefixOptIfNempty(String prefix, String s) {
  return addPrefixIfNotEmpty2(prefix, s);
}


static CloseableIterableIterator<String> linesFromFile(File f) { return linesFromFile(f, null); }
static CloseableIterableIterator<String> linesFromFile(File f, IResourceHolder resourceHolder) { try {
  if (!fileExists(f)) 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 CloseableIterableIterator<String> linesFromFile(String path) { return linesFromFile(path, null); }
static CloseableIterableIterator<String> linesFromFile(String path, IResourceHolder resourceHolder) {
  return linesFromFile(newFile(path), resourceHolder);
}




static String addPrefixIfNotEmpty2(String prefix, String s) {
  return empty(s) ? "" : addPrefix(prefix, s);
}


static CloseableIterableIterator emptyCloseableIterableIterator_instance = new CloseableIterableIterator() {
  public Object next() { throw fail(); }
  public boolean hasNext() { return false; }
};

static <A> CloseableIterableIterator<A> emptyCloseableIterableIterator() {
  return emptyCloseableIterableIterator_instance; 
}


static CloseableIterableIterator<String> linesFromReader(Reader r) { return linesFromReader(r, null); }
static 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 CloseableIterableIterator<String> linesFromReader(InputStream in) {
  return linesFromReader(inputStreamReader(in));
}




static String addPrefix(String prefix, String s) {
  return s.startsWith(prefix) ? s : prefix + s;
}


static <A extends AutoCloseable> A holdResource(IResourceHolder holder, A a) {
  { if (holder != null) holder.add(a); }
  return a;
}


static <A> CloseableIterableIterator<A> iteratorFromFunction_f0_autoCloseable(final F0<A> f, final AutoCloseable closeable) {
  class IFF2 extends CloseableIterableIterator<A> {
    A a;
    boolean done = false;
    
    public boolean hasNext() {
      getNext();
      return !done;
    }
    
    public A next() {
      getNext();
      if (done) throw fail();
      A _a = a;
      a = null;
      return _a;
    }
    
    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 String readLineFromReaderWithClose(BufferedReader r) { try {
  String s = r.readLine();
  if (s == null) r.close();
  return s;
} catch (Exception __e) { throw rethrow(__e); } }


static 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 BufferedReader inputStreamReader(InputStream in) {
  return utf8Reader(in);
}





static BufferedReader inputStreamReader(File f) {
  return utf8Reader(f);
}




static <A> A getNext(Iterator<A> it) {
  return nextFromIterator(it);
}


static BufferedReader utf8Reader(InputStream in) {
  return utf8BufferedReader(in);
}



static BufferedReader utf8Reader(File f) {
  return utf8BufferedReader(f);
}




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




static abstract class VF1<A> implements IVF1<A> {
  public abstract void get(A a);
}
// Meta - a "minimal" approach to adding meta-level to Java objects

static class Meta implements IMeta {
  
// Meta - a "minimal" approach to adding meta-level to Java objects
// (implementing the interface IMeta)

// We allocate one extra field for each Java object to make it
// reasoning-compatible (reasoning-compatible = extensible with
// fields of any name at runtime).
//
// We couldn't go for 0 extra fields (meta values must be linked
// directly from the object) and there are no half fields in
// Java... so there you go.
//
// Also, if you don't use any meta data, you are probably not
// reasoning about anything. The point of reasoning in JavaX is
// to attach information to objects directly used in the program.

// Possible information contained in the meta field:
//   Origin, destination, security level, sender, cost center,
//   purpose, list of reifications, ...

// So here it is. THE FIELD YOU HAVE BEEN WAITING FOR!

// [We also have IMeta to retrofit foreign classes (rare but
// probably useful).]

//////////////////////
// The "meta" field //
//////////////////////

// Generic meta value of any kind, but the typical case is it's a
// Map with extra field values for the object etc.
// "meta" is volatile to avoid synchronization; but you can also synchronize on
// _tempMetaMutex() which is usually the object itself. Collections
// and maps are exempt from using the collections's monitor as the meta
// mutex because their monitor tends to be held for long operations
// (e.g. cloneList). For those we use a substantially more complex
// algorithm using a weakMap. Probably overkill. I may reconsider.

volatile Object meta;

// The meta field is not transient, thus by default it will be
// persisted like anything else unless you customize your object
// to suppress or modulate this.

// ...and the interface methods

public void _setMeta(Object meta) { this.meta = meta; }
public Object _getMeta() { return meta; }

// MOST functions are implemented in IMeta (default implementations)

// Scaffolding convenience functions

final boolean scaffolding(){ return scaffoldingEnabled(); }
final boolean scaffolded(){ return scaffoldingEnabled(); }
boolean scaffoldingEnabled() { return main.scaffoldingEnabled(this); }
boolean scaffoldingEnabled(Object o) { return main.scaffoldingEnabled(o); }

// Implementing setMetaToString

String toString_base() { return super.toString(); }
public String toString() {
  Object o = metaGet("toString", this);
  if (o instanceof String) return ((String) o);
  if (o instanceof IF1) return str(((IF1) o).get(this));
  return toString_base();
}
}
static abstract class VF2<A, B> {
  abstract void get(A a, B b);
}
static 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; }
 String toolTip;
  
  WithToolTip() {}
  WithToolTip(A value, String toolTip) { super(value);
  this.toolTip = toolTip; }

  public String toString() { return formatFunctionCall("WithToolTip", toolTip, get()); }
}
static class Var<A> implements IVar<A>, ISetter<A> {
  Var() {}
  Var(A v) {
  this.v = v;}

  
  
A v; // you can access this directly if you use one thread

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 synchronized A getAndSet(A a) {
  var value = v;
  set(a);
  return value;
}

public IF0<A> getter() { return () -> get(); }
public IVF1<A> setter() { return __84 -> set(__84); }
public String toString() { return str(this.get()); }
}
static class Scorer<A> {
  double score, total;
  List<A> successes, errors; // set to non-null if you want them filled
  boolean verboseFailures, verboseAll;
  
  final void add(double score){ addZeroToOne(score); }
void addZeroToOne(double score) {
    ++total;
    this.score += clamp(score, 0, 1);
  }
  
  void addZeroToOneError(double error) {
    addZeroToOne(1-error);
  }
  
  void addError() { add(false); }
  void addError(A info) { add(false, info); }
  void error(A info) { addError(info); }
  void addOK() { add(true); }
  void addOK(A info) { add(true, info); }
  void ok() { addOK(); }
  void ok(A info) { addOK(info); }
  
  boolean add(boolean correct) {
    ++total;
    if (correct) ++score;
    return correct;
  }
  
  boolean add(boolean correct, A info) {
    main.add(correct ? successes : errors, info);
    if (verboseAll || verboseFailures && !correct)
      _print((correct ? "[GOOD] " : "[BAD] ") + info);
    return add(correct);
  }
  
  // works if you use Scorer or Scorer<S>
  void eq(Object a, Object b) {
    if (_eq(a, b))
      add(true);
    else
      add(false, (A) (a + " != " + b));
  }
  
  void print() {
    main.print(toString());
  }
  
  public String toString() {
    return formatDouble(ratioToPercent(score, total), 1) + "% correct (n=" + formatDouble(total, 1) + ")";
  }
  
  double get() {
    return ratioToPercent(score, total);
  }
  
  double percentScore() { return get(); }
  double score() { return get(); }
  
  boolean allCorrect() {
    return score == total;
  }
  
  void add(Scorer scorer) {
    if (scorer == null) return;
    total += scorer.total;
    score += scorer.score;
    addAll(successes, scorer.successes);
    addAll(errors, scorer.errors);
  }
  
  void collectErrors() {
    errors = new ArrayList();
  }
  
  void collectSuccesses() {
    successes = new ArrayList();
  }
}
// In the newest pinging system (with flag PingV3), a ping source
// is the object that "allows" some code to run.
// When that code calls ping(), the ping source's action (if defined)
// is triggered.

// This allows randomly interrupting code execution, for example.

static class PingSource {
  // returns true if it slept
   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 IF0<Boolean> action;
  
  // optional description of this ping source
  String text;
  
  // optional thread pool that this ping source likes to run in
  ThreadPool threadPool;
  
  PingSource() {}
  PingSource(ThreadPool threadPool) {
  this.threadPool = threadPool;}
  PingSource(ThreadPool threadPool, String text) {
  this.text = text;
  this.threadPool = threadPool;}
  PingSource(IF0<Boolean> action) {
  this.action = action;}

  // returns true if it slept
  final boolean get() {
    var a = action;
    return a != null && a.get();
  }
  
  final void ping() { 
    var a = action;
    if (a != null) a.get();
  }
  
  void cancel() {
    action = new Cancelled();
  }
  
  class Cancelled implements IF0<Boolean> {
    public Boolean get() { throw new PingSourceCancelledException(PingSource.this); }
  }
  
  class Encapsulated implements Runnable , IFieldsToList{
  Runnable r;
  Encapsulated() {}
  Encapsulated(Runnable r) {
  this.r = r;}public Object[] _fieldsToList() { return new Object[] {r}; }

    public void run() { try {
      //System.out.println("Encapsulated running: " + r);
      try {
        pingSource_tl().set(PingSource.this);
        //System.out.println("Ping source set");
        ping();
        r.run();
        //System.out.println("Done running");
      } finally {
        //System.out.println("Finally");
        pingSource_tl().set(null);
      }
    } catch (Exception __e) { throw rethrow(__e); } }
    
    public String toString() { return PingSource.this + ": " + r; }
  }
  
  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(); }
  
  ISleeper_v2 sleeper() { return threadPool.sleeper(); }
}
// A database system for only slightly modified Java objects.

// Recent changes:
// -minimal crash recovery disabled for now (could reenable)
// -idCounter.structure file no longer used
// -allDynamic/safeLoad disabled, it doesn't really make any sense
// -conceptsFile can be in any directory now

// Functions that should always be there for child processes:
static int concepts_internStringsLongerThan = 10;

static ThreadLocal<Boolean> concepts_unlisted = new ThreadLocal();

// BREAKING CHANGE 2021/6/7 set to true
static boolean concepts_unlistedByDefault = true; // true = we can create instances of concepts with "new" without registering them automatically

interface IConceptIndex {
  void update(Concept c); // also for adding
  void remove(Concept c);
}

interface IFieldIndex<A extends Concept, Val> {
  Collection<A> getAll(Val val);
  List<Val> allValues(); // returns a cloned list
  MultiSet<Val> allValues_multiSet();
  IterableIterator<A> objectIterator();
}

// Approach to persisting the Concepts object itself (in normal
// DB operation, this is not done): For simplification, speed and
// compactness, we make almost all the fields transient and store only // the concepts and the idCounter. To unstructure the Concepts object,
// use unstructureConcepts() or postUnstructureConcepts(), then
// re-set up any indices, listeners etc.

// base class indicating nothing
static class ConceptsChange {}

// change of a single concept
static class ConceptCreate extends ConceptsChange implements IFieldsToList{
  Concept c;
  ConceptCreate() {}
  ConceptCreate(Concept c) {
  this.c = c;}
  public String toString() { return shortClassName_dropNumberPrefix(this) + "(" + c + ")"; }

public boolean equals(Object o) {
if (!(o instanceof ConceptCreate)) return false;
    ConceptCreate __3 =  (ConceptCreate) o;
    return eq(c, __3.c);
}

  public int hashCode() {
    int h = -1751266972;
    h = boostHashCombine(h, _hashCode(c));
    return h;
  }
  public Object[] _fieldsToList() { return new Object[] {c}; }
}

// change of a single concept
static class ConceptChange extends ConceptsChange implements IFieldsToList{
  Concept c;
  ConceptChange() {}
  ConceptChange(Concept c) {
  this.c = c;}
  public String toString() { return shortClassName_dropNumberPrefix(this) + "(" + c + ")"; }

public boolean equals(Object o) {
if (!(o instanceof ConceptChange)) return false;
    ConceptChange __4 =  (ConceptChange) o;
    return eq(c, __4.c);
}

  public int hashCode() {
    int h = -1760609256;
    h = boostHashCombine(h, _hashCode(c));
    return h;
  }
  public Object[] _fieldsToList() { return new Object[] {c}; }
}

// removal of a single concept
// c.id is going to become 0 at some point, so we pass the
// id separately
static class ConceptDelete extends ConceptsChange implements IFieldsToList{
  static final String _fieldOrder = "id c";
  long id;
  Concept c;
  ConceptDelete() {}
  ConceptDelete(long id, Concept c) {
  this.c = c;
  this.id = id;}
  public String toString() { return shortClassName_dropNumberPrefix(this) + "(" + id + ", " + c + ")"; }

public boolean equals(Object o) {
if (!(o instanceof ConceptDelete)) return false;
    ConceptDelete __5 =  (ConceptDelete) o;
    return id == __5.id && eq(c, __5.c);
}

  public int hashCode() {
    int h = -1734431213;
    h = boostHashCombine(h, _hashCode(id));
    h = boostHashCombine(h, _hashCode(c));
    return h;
  }
  public Object[] _fieldsToList() { return new Object[] {id, c}; }
}

// unknown change anywhere in concepts; consider it all dirty
// (this one should not be used except for batch jobs)
static class FullChange extends ConceptsChange implements IFieldsToList{
  FullChange() {}
  public String toString() { return shortClassName_dropNumberPrefix(this); }

public boolean equals(Object o) {
return o instanceof FullChange;
}

  public int hashCode() {
    int h = 733452095;
    return h;
  }
  public Object[] _fieldsToList() { return null; }
}

static class Concepts implements AutoCloseable {
  SortedMap<Long, Concept> concepts = synchroTreeMap();
  
  // ID of last created concept
   final public long getIdCounter(){ return idCounter(); }
public long idCounter() { return idCounter; }
 long idCounter;
  
  transient HashMap<Class, Object> perClassData;
  transient Map miscMap; // don't use directly, call miscMap... methods to access
  
  // set to "-" for non-persistent (possibly not implemented)
  // also, can include a case ID ("#123/1")
  // TODO: phase out (we have conceptsFile field now)
  transient String programID;
  transient File conceptsFile;
  
  transient Concepts parent; // new mechanism
  transient volatile long changes, changesWritten, lastChange;
  transient volatile java.util.Timer autoSaver;
  transient volatile boolean dontSave = false;
  transient volatile boolean savingConcepts, noXFullGrab;
  transient boolean vmBusSend = true;
  transient boolean initialSave = false; // set to false to avoid initial useless saving
  transient int autoSaveInterval = -1000; // 1 second + wait logic
  transient boolean useGZIP = true, quietSave;
  transient ReentrantLock lock = new ReentrantLock(true);
  transient ReentrantLock saverLock = new ReentrantLock(true);
  transient long lastSaveTook = -1, lastSaveWas, loadTook, uncompressedSize;
  transient float maxAutoSavePercentage = 10;
  transient List<IConceptIndex> conceptIndices;
  transient Map<Class<? extends Concept>, Map<String, IFieldIndex>> fieldIndices;
  transient Map<Class<? extends Concept>, Map<String, IFieldIndex>> ciFieldIndices;
  //transient L saveActions = synchroList();
  transient List<Runnable> preSave;
  transient Object classFinder = _defaultClassFinder();
  transient List onAllChanged = synchroList(); // list of runnables
  transient Set<IVF1> onChange = new HashSet();
  transient Object saveWrapper; // VF1<Runnable>, to profile saving
   final public Concepts setModifyOnCreate(boolean modifyOnCreate){ return modifyOnCreate(modifyOnCreate); }
public Concepts modifyOnCreate(boolean modifyOnCreate) { this.modifyOnCreate = modifyOnCreate; return this; }  final public boolean getModifyOnCreate(){ return modifyOnCreate(); }
public boolean modifyOnCreate() { return modifyOnCreate; }
transient boolean modifyOnCreate = false; // set _modified == created initially
  transient boolean modifyOnBackRef = false; // set modified if back refs change
  transient boolean useFileLock = true; // instead of locking by bot
   final public Concepts setGrabThroughSocket(boolean grabThroughSocket){ return grabThroughSocket(grabThroughSocket); }
public Concepts grabThroughSocket(boolean grabThroughSocket) { this.grabThroughSocket = grabThroughSocket; return this; }  final public boolean getGrabThroughSocket(){ return grabThroughSocket(); }
public boolean grabThroughSocket() { return grabThroughSocket; }
transient boolean grabThroughSocket = true; // probably never want to do this again actually
  // OLD - not done anymore. transient bool collectForwardRefs
  transient FileBasedLock fileLock;
  transient boolean storeBaseClassesInStructure = false; // helps with schema evolution when concept subclasses disappear
  transient boolean useBackRefsForSearches = false; // assume backRefs are sane in order to speed up searches
  transient boolean defunct = false;
  transient int newBackupEveryXMinutes = 60;
   final public Concepts setCloseConceptsOnExit(boolean closeConceptsOnExit){ return closeConceptsOnExit(closeConceptsOnExit); }
public Concepts closeConceptsOnExit(boolean closeConceptsOnExit) { this.closeConceptsOnExit = closeConceptsOnExit; return this; }  final public boolean getCloseConceptsOnExit(){ return closeConceptsOnExit(); }
public boolean closeConceptsOnExit() { return closeConceptsOnExit; }
transient boolean closeConceptsOnExit = false;
  
  // add more fields for Concepts here
  
  Concepts() {}
  Concepts(String programID) {
  this.programID = programID;}
  Concepts(File conceptsFile) {
  this.conceptsFile = conceptsFile;}
  
  synchronized long internalID() {
    do {
      ++idCounter;
    } while (hasConcept(idCounter));
    return idCounter;
  }
  
  synchronized HashMap<Class, Object> perClassData() {
    if (perClassData == null) perClassData = new HashMap();
    return perClassData;
  }
  
  void initProgramID() {
    if (programID == null)
      programID = getDBProgramID();
  }
  
  // load from structure
  Concepts load(String structure) { return load(structure, false); }
Concepts load(String structure, boolean allDynamic) {
    clearConcepts();
    Map<Long, Concept> map = unstructureMap(structure, allDynamic, classFinder);
    concepts.putAll(map);
    assignConceptsToUs();
    calcIdCounter();
    return this;
  }
  
  Concepts load() {
    initProgramID();
    
    // try custom grabber
    Object dbGrabber = miscMapGet("dbGrabber");
    if (dbGrabber != null && !isFalse(callF(dbGrabber)))
      return this;

    try {
      if (grabThroughSocket && tryToGrab()) return this;
    } catch (Throwable e) {
      if (!exceptionMessageContains(e, "no xfullgrab"))
        printShortException(e);
      print("xfullgrab failed - loading DB of " + programID + " from disk");
    }
    return loadFromDisk();
  }
  
  Concepts loadFromDisk() {
    if (nempty(concepts)) clearConcepts();
    
    // minimal crash recovery (disabled for now)
    //restoreLatestBackupIfConceptsFileEmpty(programID, doIt := true);

    long time = now();
    Map<Long, Concept> _concepts =  (Map<Long, Concept>) (unstructureGZFile(conceptsFile(), toIF1(classFinder)));
    putAll(concepts, _concepts);
    assignConceptsToUs();
    loadTook = now()-time;
    done("Loaded " + n2(l(concepts), "concept"), time);
    calcIdCounter();
    return this;
  }
  
  Concepts loadConcepts() { return load(); }
  
  boolean tryToGrab() {
    if (sameSnippetID(programID, getDBProgramID())) return false;
     RemoteDB db = connectToDBOpt(programID); try {
    if (db != null) {
      loadGrab(db.fullgrab());
      return true;
    }
    return false;
  } finally { _close(db); }}
  
  Concepts loadGrab(String grab) {
    clearConcepts();
    DynamicObject_loading.set(true);
    try {
      Map<Long, Concept> map = (Map) unstructure(grab, false, classFinder);
      concepts.putAll(map);
      assignConceptsToUs();
      for (long l : map.keySet())
        idCounter = max(idCounter, l);
    } finally {
      DynamicObject_loading.set(null);
    }
    //XXX allChanged(); // Nobody is listening at this point anyway
    return this;
  }
  
  void assignConceptsToUs() {
    // fix unstructure bugs
    
    for (Pair<Long, Object> p: mapToPairs((Map<Long, Object>) (Map) concepts))
      if (!(p.b instanceof Concept)) {
       print("DROPPING non-existant concept " + p.a + ": " + dynShortName(p.b));
       concepts.remove(p.a);
    }
    
    for (Concept c : values(concepts)) c._concepts = this;
    for (Concept c : values(concepts))
      c._doneLoading2(); // doneLoading2 is called on all concepts after all concepts are loaded
  }

  String progID() {
    return programID == null ? getDBProgramID() : programID;
  }
  
  Concept getConcept(String id) {
    return empty(id) ? null : getConcept(parseLong(id));
  }
  
  Concept getConcept(long id) {
    return (Concept) concepts.get((long) id);
  }
  
  Concept getConcept(RC ref) {
    return ref == null ? null : getConcept(ref.longID());
  }
  
  boolean hasConcept(long id) {
    return concepts.containsKey((long) id);
  }
  
  void deleteConcept(long id) {
    Concept c = getConcept(id);
    if (c == null)
      print("Concept " + id + " not found");
    else
      c.delete();
  }
  
  void calcIdCounter() {
    Long lastID = lastKey(concepts);
    idCounter = lastID == null ? 1 : lastID+1;
  }
  
  File conceptsDir() { return dirOfFile(conceptsFile()); }
  
  Concepts conceptsFile(File conceptsFile) { this.conceptsFile = conceptsFile; return this; }
  
  File conceptsFile() {
    if (conceptsFile != null) return conceptsFile;
    
    return getProgramFile(programID, useGZIP ? "concepts.structure.gz" : "concepts.structure");
  }
  
  // used for locking when useFileLock is activated
  File lockFile() {
    return newFile(conceptsDir(), "concepts.lock");
  }
  
  FileBasedLock fileLock() {
    if (fileLock == null)
      fileLock = new FileBasedLock(lockFile());
    return fileLock;
  }
  
  void saveConceptsIfDirty() { saveConcepts(); }
  void save() { saveConcepts(); }

  void saveConcepts() {
    vmBus_send("saveConceptsCalled", Concepts.this);
    if (dontSave) return;
    initProgramID();
    saverLock.lock();
    savingConcepts = true;
    long start = now(), time;
    try {
      String s = null;
      //synchronized(main.class) {
      long _changes = changes;
      if (_changes == changesWritten) return;
      
      File f = conceptsFile();
      
      lock.lock();
      long fullTime = now();
      try {
        if (useGZIP) {
          vmBus_send("callingSaveWrapper", Concepts.this, saveWrapper);
          callRunnableWithWrapper(saveWrapper, new Runnable() {  public void run() { try { 
            vmBus_send("callingPreSave", Concepts.this, preSave);
            callFAll(preSave);
            vmBus_send("writingFile", Concepts.this, f);
            uncompressedSize = saveGZStructureToFile(f, cloneMap(concepts), makeStructureData());
            vmBus_send("gzFileSaved", Concepts.this, f, uncompressedSize);
          
} catch (Exception __e) { throw rethrow(__e); } }  public String toString() { return "vmBus_send callingPreSave(Concepts.this, preSave);\r\n            callFAll(preS..."; }});
          newFile(conceptsDir(), "concepts.structure").delete();
        } else
          s = fullStructure();
      } finally {
        lock.unlock();
      }
      
      /*while (nempty(saveActions))
        pcallF(popFirst(saveActions));*/

      changesWritten = _changes; // only update when structure didn't fail
      
      if (!useGZIP) {
        time = now()-start;
        if (!quietSave)
          print("Saving " + toM(l(s)) + "M chars (" /*+ changesWritten + ", "*/ + time + " ms)");
        start = now();
        saveTextFile(f, javaTokWordWrap(s));
        newFile(conceptsDir(), "concepts.structure.gz").delete();
      }
      
      File conceptsFile = conceptsFile();
      File backupFile = newFile(conceptsDir(), "backups/" + fileName(conceptsFile) + ".backup" + ymd() + "-" + formatInt(hours(), 2)
        + (newBackupEveryXMinutes >= 60 ? "" : formatInt(roundDownTo_rev(minutes(), newBackupEveryXMinutes), 2)));
      // TODO: get rid of this
      copyFile(f, backupFile);
      
      time = now()-start;
      if (!quietSave)
        print("Saved " + toK(f.length()) + " K, " + n(concepts, "concepts") + " (" + time + " ms)");
      lastSaveWas = fullTime;
      lastSaveTook = now()-fullTime;
    } finally {
      savingConcepts = false;
      saverLock.unlock();
    }
  }
  
  void _autoSaveConcepts() {
    if (autoSaveInterval < 0 && maxAutoSavePercentage != 0) {
      long pivotTime = Math.round(lastSaveWas+lastSaveTook*100.0/maxAutoSavePercentage);
      if (now() < pivotTime) {
        //print("Skipping auto-save (last save took " + lastSaveTook + ")");
        return;
      }
    }
    try {
      saveConcepts();
    } catch (Throwable e) {
      print("Concept save failed, will try again");
      printStackTrace(e);
    }
  }
  
  String fullStructure() {
    return structure(cloneMap(concepts), makeStructureData());
  }
  
  transient  IF0<structure_Data> makeStructureData;
structure_Data makeStructureData() { return makeStructureData != null ? makeStructureData.get() : makeStructureData_base(); }
final structure_Data makeStructureData_fallback(IF0<structure_Data> _f) { return _f != null ? _f.get() : makeStructureData_base(); }
structure_Data makeStructureData_base() {
    return finishStructureData(new structure_Data());
  }
  
  structure_Data finishStructureData(structure_Data data) {
    if (storeBaseClassesInStructure)
      data.storeBaseClasses = true;
    return data;
  }
  
  void clearConcepts() {
    for (Concept c : allConcepts()) c.delete();
    //concepts.clear();
    //allChanged();
  }
  
  void fireLegacyChangeEvent() {
    synchronized(this) { ++changes; lastChange = sysNow(); }
    if (vmBusSend) vmBus_send("conceptsChanged", this);
    pcallFAll(onAllChanged);
  }
  
  // auto-save every second if dirty
  synchronized void autoSaveConcepts() {
    if (autoSaver == null) {
      if (isTransient()) throw fail("Can't persist transient database");
      autoSaver = doEvery_daemon("Concepts Saver for " + conceptsDir(),
        abs(autoSaveInterval), new Runnable() {  public void run() { try {  _autoSaveConcepts() ;
} catch (Exception __e) { throw rethrow(__e); } }  public String toString() { return "_autoSaveConcepts()"; }});
      // print("Installed auto-saver (" + autoSaveInterval + " ms, " + progID() + ")");
    }
  }
  
  public void close() { cleanMeUp(); }
  
  void cleanMeUp() {
    try {
      if (closeConceptsOnExit)
        closeAllOpt(allConcepts());
        
      defunct = true;
      boolean shouldSave = autoSaver != null;
      if (autoSaver != null) {
        autoSaver.cancel();
        autoSaver = null;
      }
      while (savingConcepts) sleepInCleanUp(10);
      if (shouldSave)
        saveConceptsIfDirty();
    } catch (Throwable __e) { pcallFail(__e); }
    { cleanUp(fileLock); fileLock = null; }
  }
  
  Map<Long, String> getIDsAndNames() {
    Map<Long, String> map = new HashMap();
    Map<Long, Concept> cloned = cloneMap(concepts);
    for (long id : keys(cloned)) 
      map.put(id, cloned.get(id).className);
    return map;
  }
  
  void deleteConcepts(List l) {
    ping();
    if (l != null) for (Object o : cloneList(l))
      if (o instanceof Long) {
        Concept c = concepts.get(o);
        if (c != null) c.delete();
      } else if (o instanceof Concept)
        ((Concept) o).delete();
      else
        warn("Can't delete " + getClassName(o));
  }
  
  <A extends Concept> A conceptOfType(Class<A> type) {
    IConceptCounter counter = conceptCounterForClass(type);
    if (counter != null) return (A) first(counter.allConcepts());
    return firstOfType(allConcepts(), type);
  }
  
  <A extends Concept> List<A> conceptsOfType(Class<A> type) {
    List<A> l = conceptsOfType_noParent(type);
    if (parent == null) return l;
    return concatLists_conservative(l, parent.conceptsOfType(type));
  }
  
  <A extends Concept> List<A> conceptsOfType_noParent(Class<A> type) {
    ping();
    IConceptCounter counter = conceptCounterForClass(type);
    if (counter != null) return (List<A>) cloneList(counter.allConcepts());
    return filterByType(allConcepts(), type);
  }
  
  <A extends Concept> List<A> listConcepts(Class<A> type) {
    return conceptsOfType(type);
  }
  
  <A extends Concept> List<A> list(Class<A> type) {
    return conceptsOfType(type);
  }
  
  <A extends Concept> List<A> list_noParent(Class<A> type) {
    return conceptsOfType_noParent(type);
  }
  
  // TODO: would be better to make this Cl (indices may return sets)
  List<Concept> list(String type) {
    return conceptsOfType(type);
  }
  
  List<Concept> conceptsOfType(String type) {
    return filterByDynamicType(allConcepts(), "main$" + type);
  }
  
  boolean hasConceptOfType(Class<? extends Concept> type) {
    return hasType(allConcepts(), type);
  }
  
  void persistConcepts() {
    loadConcepts();
    autoSaveConcepts();
  }
  
  // We love synonyms
  void conceptPersistence() { persistConcepts(); }
  
  Concepts persist() { persistConcepts(); return this; }
  void persist(Integer interval) {
    if (interval != null) autoSaveInterval = interval;
    persist();
  }
    
  // Runs r if there is no concept of that type
  <A extends Concept> A ensureHas(Class<A> c, Runnable r) {
    A a = conceptOfType(c);
    if (a == null) {
      r.run();
      a = conceptOfType(c);
      if (a == null)
        throw fail("Concept not made by " + r + ": " + shortClassName(c));
    }
    return a;
  }
  
  // Ensures that every concept of type c1 is ref'd by a concept of
  // type c2.
  // Type of func: voidfunc(concept)
  void ensureHas(Class<? extends Concept> c1, Class<? extends Concept> c2, Object func) {
    for (Concept a : conceptsOfType(c1)) {
      Concept b = findBackRef(a, c2);
      if (b == null) {
        callF(func, a);
        b = findBackRef(a, c2);
        if (b == null)
          throw fail("Concept not made by " + func + ": " + shortClassName(c2));
      }
    }
  }
  
  // Type of func: voidfunc(concept)
  void forEvery(Class<? extends Concept> type, Object func) {
    for (Concept c : conceptsOfType(type))
      callF(func, c);
  }
  
  int deleteAll(Class<? extends Concept> type) {
    List<Concept> l = (List) conceptsOfType(type);
    for (Concept c : l) c.delete();
    return l(l);
  }
  
  // always returns a new list (callers depend on this)
  Collection<Concept> allConcepts() {
    synchronized(concepts) {
      return new ArrayList(values(concepts));
    }
  }
  
  IConceptCounter conceptCounterForClass(Class<? extends Concept> c) {
    for (IFieldIndex idx : values(mapGet(fieldIndices, c)))
      if (idx instanceof IConceptCounter) return ((IConceptCounter) idx);
    for (IFieldIndex idx : values(mapGet(ciFieldIndices, c)))
      if (idx instanceof IConceptCounter) return ((IConceptCounter) idx);
    return null;
  }
  

  <A extends Concept> int countConcepts(Class<A> c, Object... params) {
    int n = countConcepts_noParent(c, params);
    if (parent == null) return n;
    return n+parent.countConcepts(c, params);
  }
  
  <A extends Concept> int countConcepts_noParent(Class<A> c, Object... params) {
    ping();
    if (empty(params)) {
      IConceptCounter counter = conceptCounterForClass(c);
      if (counter != null) return counter.countConcepts();
      return l(list_noParent(c));
    }
    int n = 0;
    for (A x : list_noParent(c)) if (checkConceptFields(x, params)) ++n;
    return n;
  }

  int countConcepts(String c, Object... params) {
    ping();
    if (empty(params)) return l(list(c));
    int n = 0;
    for (Concept x : list(c)) if (checkConceptFields(x, params)) ++n;
    return n;
  }

  int countConcepts() {
    return l(concepts);
  }
  
  synchronized List<IConceptIndex> clonedConceptIndices() {
    return cloneList(conceptIndices);
  }
  
  synchronized void addConceptIndex(IConceptIndex index) {
    if (conceptIndices == null)
      conceptIndices = new ArrayList();
    conceptIndices.add(index);
  }
  
  synchronized void removeConceptIndex(IConceptIndex index) {
    if (conceptIndices == null) return;
    conceptIndices.remove(index);
    if (empty(conceptIndices)) conceptIndices = null;
  }
  
  synchronized void addFieldIndex(Class<? extends Concept> c, String field, IFieldIndex index) {
    if (fieldIndices == null)
      fieldIndices = new HashMap();
    Map<String, IFieldIndex> map = fieldIndices.get(c);
    if (map == null)
      fieldIndices.put(c, map = new HashMap());
    map.put(field, index);
  }
  
  synchronized void removeFieldIndex(Class<? extends Concept> c, String field, IFieldIndex index) {
    Map<String, IFieldIndex> map = mapGet(fieldIndices, c);
    mapRemove(map, field);
  }
  
  synchronized IFieldIndex getFieldIndex(Class<? extends Concept> c, String field) {
    if (fieldIndices == null) return null;
    Map<String, IFieldIndex> map = fieldIndices.get(c);
    return map == null ? null : map.get(field);
  }
  
  synchronized IFieldIndex getAnyIndexForClass(Class<? extends Concept> c) {
    return first(allIndicesForClass(c));
  }
  
  synchronized Collection<IFieldIndex> allIndicesForClass(Class<? extends Concept> c) {
    return concatLists(
      values(fieldIndices == null ? null : fieldIndices.get(c)),
      values(ciFieldIndices == null ? null : ciFieldIndices.get(c)));
  }
  
  synchronized void addCIFieldIndex(Class<? extends Concept> c, String field, IFieldIndex index) {
    if (ciFieldIndices == null)
      ciFieldIndices = new HashMap();
    Map<String, IFieldIndex> map = ciFieldIndices.get(c);
    if (map == null)
      ciFieldIndices.put(c, map = new HashMap());
    map.put(field, index);
  }
  
  synchronized void removeCIFieldIndex(Class<? extends Concept> c, String field) {
    Map<String, IFieldIndex> map = mapGet(ciFieldIndices, c);
    mapRemove(map, field);
  }
  
  synchronized IFieldIndex getCIFieldIndex(Class<? extends Concept> c, String field) {
    if (ciFieldIndices == null) return null;
    Map<String, IFieldIndex> map = ciFieldIndices.get(c);
    return map == null ? null : map.get(field);
  }
  
  // inter-process methods
  
  RC xnew(String name, Object... values) {
    return new RC(cnew(name, values));
  }
  
  void xset(long id, String field, Object value) {
    xset(new RC(id), field, value);
  }
  
  void xset(RC c, String field, Object value) {
    if (value instanceof RC)
      value = getConcept((RC) value);
    cset(getConcept(c), field, value);
  }
  
  Object xget(long id, String field) {
    return xget(new RC(id), field);
  }
  
  Object xget(RC c, String field) {
    return xgetPost(cget(getConcept(c), field));
  }
  
  Object xgetPost(Object o) {
    o = deref(o);
    if (o instanceof Concept)
      return new RC((Concept) o);
    return o;
  }
  
  void xdelete(long id) {
    xdelete(new RC(id));
  }
  
  void xdelete(RC c) {
    getConcept(c).delete();
  }
  
  void xdelete(List<RC> l) {
    for (RC c : l)
      xdelete(c);
  }
  
  List<RC> xlist() {
    return map("toPassRef", allConcepts());
  }
  
  List<RC> xlist(String className) {
    return map("toPassRef", conceptsOfType(className));
  }
  
  boolean isTransient() { return eq(programID, "-"); }
  
  String xfullgrab() {
    if (noXFullGrab) throw fail("no xfullgrab (DB too large)");
    Lock __1 = lock(); lock(__1); try {
    if (changes == changesWritten && !isTransient())
      return loadConceptsStructure(programID);
    return fullStructure();
  } finally { unlock(__1); } }
  
  /* dev.
  Either<File, byte[]> xfullgrabGZipped() {
    lock lock();
    if (changes == changesWritten && !isTransient())
      ret loadConceptsStructure(programID);
    ret fullStructure();
  }*/
  
  void xshutdown() {
    // Killing whole VM if someone wants this DB to shut down
    cleanKillVM();
  }
  
  long xchangeCount() { return changes; }
  int xcount() { return countConcepts(); }
  
  void register(Concept c) {
    ping();
    if (c._concepts == this) return;
    if (c._concepts != null) throw fail("Can't re-register");
    c.id = internalID();
    c.created = now();
    if (modifyOnCreate) c._setModified(c.created);
    register_phase2(c);
    vmBus_send("conceptCreated", c);
    fireChange(new ConceptCreate(c));
  }
  
  // also called by replaceConceptAndUpdateRefs
  void register_phase2(Concept c) {
    c._concepts = this;
    concepts.put((long) c.id, c);
    for (Concept.Ref r : c._refs())
      r.index();
    c.change();
    c._onRegistered();
  }
  
  void registerKeepingID(Concept c) {
    if (c._concepts == this) return;
    if (c._concepts != null) throw fail("Can't re-register");
    c._concepts = this;
    concepts.put((long) c.id, c);
    c.change();
  }
  
  void conceptChanged(Concept c) {
    fireChange(new ConceptChange(c));
    if (conceptIndices != null)
      for (IConceptIndex index : clonedConceptIndices())
        index.update(c);
  }
  
  boolean hasUnsavedData() {
    return changes != changesWritten || savingConcepts;
  }
  
  synchronized Object miscMapGet(Object key) {
    return mapGet(miscMap, key);
  }
  
  synchronized Object miscMapPut(Object key, Object value) {
    if (miscMap == null) miscMap = new HashMap();
    return miscMap.put(key, value);
  }
  
  synchronized void miscMapRemove(Object key) {
    mapRemove(miscMap, key);
  }
  
  // Note: auto-typing can fool you, make sure create returns
  // a wide enough type
  synchronized <A> A miscMapGetOrCreate(Object key, IF0<A> create) {
    if (containsKey(miscMap, key)) return (A) miscMap.get(key);
    A value = create.get();
    miscMapPut(key, value);
    return value;
  }
  
  void setParent(Concepts parent) {
    this.parent = parent;
  }
  
  void fireChange(ConceptsChange change) {
    if (change == null) return;
    pcallFAll(onChange, change);
    fireLegacyChangeEvent();
  }
  
  final void onChange(IVF1<ConceptsChange> l){ addChangeListener(l); }
void addChangeListener(IVF1<ConceptsChange> l) {
    syncAdd(onChange, l);
  }
  
  void removeChangeListener(IVF1<ConceptsChange> l) {
    syncRemove(onChange, l);
  }
  
  void addPreSave(Runnable r) {
    preSave = syncAddOrCreate(preSave, r);
  }
  
  public String toString() {
    return nConcepts(concepts) + " (" + conceptsDir() + ", hash: " + identityHashCode(this) + ")";
  }
} // end of Concepts

// TODO: Move everyone over to this so we can have concepts that
// don't subclass Concept. It's hard though because of Concept.Ref
interface IConcept {
  public long _conceptID();
  public Concepts concepts();
}

static class Concept extends DynamicObject implements IConcept, ChangeTriggerable {
  transient Concepts _concepts; // Where we belong
  long id;
  long created, _modified;
  
  List<Ref> backRefs;
  
  // used only internally (cnew)
  Concept(String className) {
    super(className);
    _created();
  }
  
  Concept() {
    if (!_loading()) {
      //className = shortClassName(this); // XXX - necessary?
      //print("New concept of type " + className);
      _created();
    }
  }
  
  Concept(boolean unlisted) {
    if (!unlisted) _created();
  }
  
  boolean includeZeroIDInToString() { return false; }
  
  public String toString() {
    String s = shortDynamicClassName(this);
    long id = this.id;
    if (id != 0 || includeZeroIDInToString())
      s += " " + id;
    return s;
  }
  
  static boolean loading() { return _loading(); }
  static boolean _loading() { return dynamicObjectIsLoading(); }

  void _created() {
    if (!concepts_unlistedByDefault && !eq(concepts_unlisted.get(), true))
      db_mainConcepts().register(this);
  }
  
  // base class + required interface. experimental
  class TypedRef<A extends Concept, B> extends Ref<A> {
  TypedRef() {}
    //Class<B> aType;
    Class<B> bType;
    
    TypedRef(Class<B> bType) {
  this.bType = bType;}
    TypedRef(Class<B> bType, B value) {
  this.bType = bType; set((A) value); }
    TypedRef(B value) { set((A) value); }
    
    public boolean set(A a) {
      return super.set(checkValue(a));
    }
    
    void check() { checkValue(get()); }
    
    <C> C checkValue(C a) {
      if (bType != null && a != null)
        assertIsInstance(a, bType);
      return a;
    }
    
    B b() { return (B) value; }
  }
  
  class Ref<A extends Concept> implements IRef<A> {
    A value;
    
    Ref() {
      if (!dynamicObjectIsLoading())
        registerRef();
    }
    
    void registerRef() {
      vmBus_send("registeringConceptRef", this);
    }
    
    Ref(A value) {
  this.value = value;
      registerRef();
      index();
    }
    
    // get owning concept (source)
    Concept concept() {
      return Concept.this;
    }
    
    // get target
    public A get() { return value; }
    public boolean has() { return value != null; }
    
    boolean set(A a) {
      if (a == value) return false;
      unindex();
      value = a;
      index();
      change();
      return true;
    }
    
    void setIfEmpty(A a) {
      if (!has()) set(a);
    }
    
    public void set(Ref<A> ref) { set(ref.get()); }
    public void clear() { set((A) null); }
    
    boolean validRef() {
      return value != null && _concepts != null && _concepts == value._concepts;
    }
    
    // TODO: sync all the indexing and unindexing!?
    void index() { 
      if (validRef()) {
        value._addBackRef(this);
        change();
      }
    }

    Ref<A> unindex() {
      if (validRef()) {
        value._removeBackRef(this);
        change();
      }
      return this;
    }
    
    void unindexAndDrop() {
      unindex();
      _removeRef(this);
    }
    
    void change() {
      Concept.this.change();
    }
    
    public String toString() { return 
    str(value); }
  }
  
  class RefL<A extends Concept> extends AbstractList<A> {
    List<Ref<A>> l = new ArrayList();
    
    RefL() {}
    RefL(List<A> l) { replaceWithList(l); }
    
    public void clear() {
      while (!isEmpty()) removeLast(this);
    }
    
    public void replaceWithList(List<A> l) {
      clear();
      for (A a : unnullForIteration(l)) add(a);
    }
    
    public A set(int i, A o) {
      Ref<A> ref = syncGet(l, i);
      A prev = ref.get();
      ref.set(o);
      return prev;
    }
    
    public void add(int i, A o) {
      syncAdd(l, i, new Ref(o));
    }
    
    public A get(int i) {
      return syncGet(l, i).get();
    }
    
    public A remove(int i) {
      return syncRemove(l, i).get();
    }
    
    public int size() {
      return syncL(l);
    }
    
    public boolean contains(Object o) {
      if (o instanceof Concept)
        for (Ref<A> r : l) if (eq(r.get(), o)) return true;
      return super.contains(o);
    }
  }
  
  void delete() {
    //name = "[defunct " + name + "]";
    //defunct = true;
    //energy = 0;
    
    // clean refs
    
    for (Ref r : unnullForIteration(_refs()))
      r.unindex();
    
    
    // set back refs to null
    
    for (Ref r : cloneList(backRefs))
      r.set((Concept) null);
    backRefs = null;
    
    var _concepts = this._concepts;
    if (_concepts != null) {
      _concepts.concepts.remove(id);
      _concepts.fireChange(new ConceptDelete(id, this));
      if (_concepts.conceptIndices != null)
        for (IConceptIndex index : _concepts.conceptIndices)
          index.remove(this);
      this._concepts = null;
    }
    id = 0;
  }
  
  BaseXRef export() {
    return new BaseXRef(_concepts.progID(), id);
  }
  
  // notice system of a change in this object
  final public void _change(){ change(); }
public void change() {
    _setModified(now());
    _change_withoutUpdatingModifiedField();
  }
  
  void _setModified(long modified) {
    _modified = modified;
  }
  
  final void _change_withoutUpdatingModifiedField() {
    _onChange();
    if (_concepts != null) _concepts.conceptChanged(this);
  }
  
  // overridable
  void _onChange() {}
  
  String _programID() {
    return _concepts == null ? getDBProgramID() : _concepts.progID();
  }
  
  // overridable
  
  void _addBackRef(Concept.Ref ref) {
    backRefs = addDyn_quickSync(backRefs, ref);
    _backRefsModified();
  }
  
  void _backRefsModified() {
    if (_concepts != null && _concepts.modifyOnBackRef) change();
  }
  
  void _removeBackRef(Concept.Ref ref) {
    backRefs = removeDyn_quickSync(backRefs, ref);
    _backRefsModified();
  }
  
  void _removeRef(Concept.Ref ref) {
    
  }
  
  int _backRefCount() { return syncL(backRefs); }
  
  // convenience methods
  
  final void setField(String field, Object value){ _setField(field, value); }
void _setField(String field, Object value) {
    cset(this, field, value);
  }
  
  boolean setField_trueIfChanged(String field, Object value) {
    return cset(this, field, value) != 0;
  }
  
  <A> A setFieldAndReturn(String field, A value) {
    setField(field, value);
    return value;
  }
  
  final void setFields(Object... values){ _setFields(values); }
void _setFields(Object... values) {
    cset(this, values);
  }
  
  public Concepts concepts() { return _concepts; }
  
  boolean isDeleted() { return id == 0; }
  
  // Called directly after concept is unstructured
  void _doneLoading() {}
  
  // Called after all concepts are unstructured and added to Concepts
  void _doneLoading2() {
    Map<String, FieldMigration> map = _fieldMigrations();
    if (map != null) for (Map.Entry<? extends String, ? extends FieldMigration> __0 : _entrySet( map))
      { String oldField = __0.getKey(); FieldMigration m = __0.getValue();  crenameField_noOverwrite(this, oldField, m.newField); }
  }
  
  static class FieldMigration implements IFieldsToList{
  String newField;
  FieldMigration() {}
  FieldMigration(String newField) {
  this.newField = newField;}
  public String toString() { return shortClassName_dropNumberPrefix(this) + "(" + newField + ")"; }

public boolean equals(Object o) {
if (!(o instanceof FieldMigration)) return false;
    FieldMigration __6 =  (FieldMigration) o;
    return eq(newField, __6.newField);
}

  public int hashCode() {
    int h = 558692372;
    h = boostHashCombine(h, _hashCode(newField));
    return h;
  }
  public Object[] _fieldsToList() { return new Object[] {newField}; }
}
  
  // value is 
  Map<String, FieldMigration> _fieldMigrations() { return null; }
  
  // new wrapper to get a copy of the refs list
  // so we can eventually drop the refs field
  Collection<Ref> _refs() {
    return scanConceptForRefs(this);
  }
  
  
  
  Concepts _concepts() { return _concepts; }
  
  boolean _conceptsDefunct() { return _concepts != null && _concepts.defunct; }
  boolean _conceptsDefunctOrUnregistered() { return _concepts == null || _concepts.defunct; }
  
  // allow refs to do magic stuff?
  void _onRegistered() {
    /*for (Ref ref : _refs())
      refs._onRegistered();*/
  }
  
  
<A> boolean addAndChange(Collection<A> cl, A a) {
  if (cl == null || !cl.add(a)) return false;
  change();
  return true;
}

<A> void clearAndChange(Collection<A> cl) {
  if (cl == null) return;
  cl.clear();
  change();
}


File conceptsDir() {
    var concepts = concepts();
    return concepts == null ? null : concepts.conceptsDir();
  }
  
  File fileInConceptsDir(String name) {
    var dir = conceptsDir();
    return dir == null ? null : newFile(dir, name);
  }
  
  public long _conceptID() { return id; }
} // end of Concept

// remote reference (for inter-process communication or
// external databases). Formerly "PassRef".
// prepared for string ids if we do them later
static class RC {
  transient Object owner;
  String id;
  
  RC() {} // make serialisation happy
  RC(long id) { this.id = str(id); }
  RC(Object owner, long id) { this.id = str(id); this.owner = owner; }
  RC(Concept c) { this(c.id); }
  long longID() { return parseLong(id); }
  
  public String toString() {
    return id;
  }

  transient RemoteDB db;
  
  String getString(String field) { return db.xS(this, field); }
  Object get(String field) { return db.xget(this, field); }
  void set(String field, Object value) { db.xset(this, field, value); }

} // end of RC

// Reference to a concept in another program
static class BaseXRef {
  String programID;
  long id;
    
  BaseXRef() {}
  BaseXRef(String programID, long id) {
  this.id = id;
  this.programID = programID;}
  
  public boolean equals(Object o) {
    if (!(o instanceof BaseXRef)) return false;
    BaseXRef r =  (BaseXRef) o;
    return eq(programID, r.programID) && eq(id, r.id);
  }
  
  public int hashCode() {
    return programID.hashCode() + (int) id;
  }
}

// BaseXRef as a concept
static class XRef extends Concept {
  BaseXRef ref;
  
  XRef() {}
  XRef(BaseXRef ref) {
  this.ref = ref; _doneLoading2(); }
  
  // after we have been added to concepts
  void _doneLoading2() {
    getIndex().put(ref, this);
  }
    
  HashMap<BaseXRef, XRef> getIndex() {
    return getXRefIndex(_concepts);
  }
}

static synchronized HashMap<BaseXRef, XRef> getXRefIndex(Concepts concepts) {
  HashMap cache = (HashMap) concepts.perClassData().get(XRef.class);
  if (cache == null)
    concepts.perClassData.put(XRef.class, cache = new HashMap());
  return cache;
}

// uses mainConcepts
static XRef lookupOrCreateXRef(BaseXRef ref) {
  XRef xref = getXRefIndex(db_mainConcepts()).get(ref);
  if (xref == null)
    xref = new XRef(ref);
  return xref;
}

// define standard concept functions to use main concepts

// Now in db_mainConcepts()
/*static void cleanMeUp_concepts() {
  if (db_mainConcepts() != null) db_mainConcepts().cleanMeUp();
  // mainConcepts = null; // TODO
}*/

static void loadAndAutoSaveConcepts() {
  db_mainConcepts().persist();
}

static void loadAndAutoSaveConcepts(int interval) {
  db_mainConcepts().persist(interval);
}

static RC toPassRef(Concept c) {
  return new RC(c);
}

// so we can instantiate the program to run as a bare DB bot
static void concepts_setUnlistedByDefault(boolean b) {
  concepts_unlistedByDefault = b;
}
// AppendableChain has one "smart" head element (with size counter
// and pointer to the chain's last element), all the other nodes are
// maximally simple (MinimalChain).
// This allows O(1) front insertion, front removal and back insertion
// (not removal at the back though) which is fine for what I need this
// for (event queues).
//
// Stefan Reich, Oct 21

static class AppendableChain<A> extends MinimalChain<A> implements Iterable<A>, IntSize {
  MinimalChain<A> last; // pointer to last element in chain (which may be us)
   final public int getSize(){ return size(); }
public int size() { return size; }
 int size; // total length of chain

  AppendableChain() {} // only used internally
  AppendableChain(A element) {
  this.element = element; size = 1; last = this; }
  
  // intermediate constructor called by itemPlusChain()
  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()); }
  
  // append at the end
  boolean add(A a) {
    MinimalChain newLast = new MinimalChain(a);
    last.next = newLast;
    last = newLast;
    ++size;
    return true;
  }
  
  // drop first element
  AppendableChain<A> popFirst() {
    if (next == null) return null;
    element = next.element;
    if (last == next) last = this;
    next = next.next;
    --size;
    return this;
  }
  
  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 Iterator<A> iterator() { ret toList().iterator(); }
  
  class ACIt extends IterableIterator  < A > {
    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();
  }
}
interface IntSize {
  int size();
  
  default boolean isEmpty() { return size() == 0; }
}
// -has fast nextElement() and prevElement()
// -design allows for more functions like reordering the list
// -Saves up to 34% in space over LinkedHashSet
//    (e.g. 22% for a set of 1,000 Ints)
static class CompactLinkedHashSet<A> extends AbstractSet<A> {
  UnsynchronizedCompactHashSet<Entry<A>> entries = new UnsynchronizedCompactHashSet();
  Entry<A> head, tail;
  
  static class Entry<A> {
    A value;
    Entry<A> prev, next;
    
    public int hashCode() {
      return _hashCode(value);
    }
    
    // "magic" equals function for CompactHashSet lookup without temp object
    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>() {
      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;
      }
      
      // untested
      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; }
  
  boolean removeIfSame(Object o) {
    A value = find(o);
    if (value == o) {
      remove(value);
      return true;
    }
    return false;
  }
}
static class Fail extends RuntimeException implements IFieldsToList{
  Object[] objects;
  Fail() {}
  Fail(Object... objects) {
  this.objects = objects;}public Object[] _fieldsToList() { return new Object[] {objects}; }

  Fail(Throwable cause, Object... objects) {
    super(cause);
  this.objects = objects;
  }
  
  public String toString() { return joinNemptiesWithColon("Fail", getMessage()); }
  
  public String getMessage() { return commaCombine(getCause(), objects); }
}
// for an example, see #1027660
static class CRUD<A extends Concept> implements Swingable {
  CRUD() {}
  CRUD(Class<A> conceptClass) {
  this.conceptClass = conceptClass;}
  CRUD(Concepts cc, Class<A> conceptClass) {
  this.conceptClass = conceptClass;
  this.cc = cc;}
  
  
static boolean _switchableField_caseID = true; String caseID;
transient Concepts cc = db_mainConcepts();
transient Class<A> conceptClass;
transient SimpleCRUD<A> crud;
transient boolean addCountToName = true, addCountToName_installed;
transient boolean ensureIndexed = false;

void start_DynCRUD() {
   // set flag to save space
  if (cc == db_mainConcepts())
    dbWithCase(caseID); // So we can do stuff in overridden start methods
  
  crud = makeCRUD(); // so we can customize early
  if (addCountToName) addCountToName();
}

JComponent visualizeWithCountInTab() {
  JComponent c = visualize();
  bindToComponent(table(), new Runnable() {  public void run() { try {  updateTabTitle(); 
} catch (Exception __e) { throw rethrow(__e); } }  public String toString() { return "updateTabTitle();"; }});
   AutoCloseable __57 = tempSetTL(awtOnConceptChanges_concepts, cc); try {
  awtOnConceptChanges(table(), new Runnable() {  public void run() { try {  updateTabTitle(); 
} catch (Exception __e) { throw rethrow(__e); } }  public String toString() { return "updateTabTitle();"; }});
  return c;
} finally { _close(__57); }}

void updateTabTitle() {
  updateEnclosingTabTitleWithCount(table(), conceptCount());
}

public JComponent visualize() {
  if (crud == null) start_DynCRUD();
  makeConceptsTable_idWidth = 0;
  showConceptsTable_afterUpdate.set(new VF1<JTable>() { public void get(JTable t) { try { 
    int n = tableColumnCount(t);
    for (int i = 0; i < n; i++)
      setColumnName(t, i, i == 0 ? "" : humanizeFormLabel(getColumnName(t, i)));
   } catch (Exception __e) { throw rethrow(__e); } }
  public String toString() { return "int n = tableColumnCount(t);\r\n    for i to n:\r\n      setColumnName(t, i, i ==..."; }});
  return withMargin(crud.make_dontStartBots());
}

SimpleCRUD<A> makeCRUD() {
  var crud = new SimpleCRUD<A>(cc, conceptClass);
  crud.ensureIndexed = ensureIndexed;
  return crud;
}

JTable table() { return crud == null ? null : crud.table; }

A selected() { return crud == null ? null : crud.selectedConcept(); }

void addButton(JComponent button) {
  if (crud != null) addComponent(crud.buttons, button);
}
void addButton(String name, Object action) { addButton(jbutton(name, action)); }
void addSelectionDependentButton(String name, Object action) {
  addButton(tableDependentButton(table(), name, toRunnable(action)));
}

void makeSortable() { // broken?
  addRowSorter(table());
  rowSorter_setComparatorForAllColumns(table(), alphaNumComparator());
}

String searchTerm() {
  return crud == null || crud.tableSearcher == null ? null : gtt(crud.tableSearcher.tfInput);
}

void addCountToName() {
  if (addCountToName_installed) return;
  addCountToName_installed = true;
  onConceptChangeAndNow(cc, new Runnable() {  public void run() { try {   AutoCloseable __58 = enter(); try {  setModuleName(dm_originalModuleName() + " (" + conceptCount() + ")") ;
} finally { _close(__58); }} catch (Exception __e) { throw rethrow(__e); } }  public String toString() { return "temp enter();  setModuleName(dm_originalModuleName() + \" (\" + conceptCount() ..."; }});
}

Concepts conceptsObject() {
  return crud.concepts;
}

// overwrite for compact modules to work

<B extends Concept> List<B> list(Class<B> c) {
  return conceptsObject().list(c);
}

// API

List<A> concepts() {  AutoCloseable __59 = enter(); try { return list(conceptClass); } finally { _close(__59); }}
List<A> data() { return concepts(); }
List<A> list() { return concepts(); }

List<Concept> conceptsOfType(String type) {  AutoCloseable __60 = enter(); try { return conceptsObject().list(type); } finally { _close(__60); }}

// TODO: use index
List<Concept> conceptsOfTypeWhere(String type, Object[] params) {  AutoCloseable __61 = enter(); try {
  return filterConcepts(conceptsOfType(type), params);
} finally { _close(__61); }}

int conceptCount() {  AutoCloseable __62 = enter(); try { return countConcepts(cc, conceptClass); } finally { _close(__62); }}

void deleteAll() {  AutoCloseable __63 = enter(); try {
  deleteConcepts(cc, conceptClass);
} finally { _close(__63); }}

void addDialog() {  AutoCloseable __64 = enter(); try { crud.newConcept(); } finally { _close(__64); }}

A uniqConcept(Object... params) {
  return uniq_sync(cc, conceptClass, params);
}

Pair<A, Boolean> uniqConcept2(Object... params) {
  return uniq2_sync(cc, conceptClass, params);
}

int cset(Concept c, Object... values) {
  return _cset(c, values);
}
transient  IF0<AutoCloseable> enter;
AutoCloseable enter() { return enter != null ? enter.get() : enter_base(); }
final AutoCloseable enter_fallback(IF0<AutoCloseable> _f) { return _f != null ? _f.get() : enter_base(); }
AutoCloseable enter_base() { return null; }
  transient  IVF1<String> setModuleName;
void setModuleName(String name) { if (setModuleName != null) setModuleName.get(name); else setModuleName_base(name); }
final void setModuleName_fallback(IVF1<String> _f, String name) { if (_f != null) _f.get(name); else setModuleName_base(name); }
void setModuleName_base(String name) {}
}
static class Rect implements WidthAndHeight , IFieldsToList{
  static final String _fieldOrder = "x y w h";
  int x;
  int y;
  int w;
  int h;
  Rect() {}
  Rect(int x, int y, int w, int h) {
  this.h = h;
  this.w = w;
  this.y = y;
  this.x = x;}

public boolean equals(Object o) {
if (!(o instanceof Rect)) return false;
    Rect __1 =  (Rect) o;
    return x == __1.x && y == __1.y && w == __1.w && h == __1.h;
}

  public int hashCode() {
    int h = 2543108;
    h = boostHashCombine(h, _hashCode(x));
    h = boostHashCombine(h, _hashCode(y));
    h = boostHashCombine(h, _hashCode(w));
    h = boostHashCombine(h, _hashCode(h));
    return h;
  }
  public Object[] _fieldsToList() { return new Object[] {x, y, w, h}; }

  Rect(Rectangle r) {
    x = r.x;
    y = r.y;
    w = r.width;
    h = r.height;
  }
  
  Rect(Pt p, int w, int h) {
  this.h = h;
  this.w = w; x = p.x; y = p.y; }
  Rect(Rect r) { x = r.x; y = r.y; w = r.w; h = r.h; }
  
  final Rectangle getRectangle() {
    return new Rectangle(x, y, w, h);
  }
  
  public String toString() {
    return x + "," + y + " / " + w + "," + h;
  }
  
  final int x1() { return x; }
  final int y1() { return y; }
  final int x2() { return x + w; }
  final int y2() { return y + h; }
  
  final boolean contains(Pt p) {
    return contains(p.x, p.y);
  }
  
  final boolean contains(int _x, int _y) {
    return _x >= x && _y >= y && _x < x+w && _y < y+h;
  }
  
  final boolean contains(Rectangle r) {
    return rectContains(this, r);
  }
  
  final boolean empty() { return w <= 0 || h <= 0; }
  
  final public int getWidth() { return w; }
  final public int getHeight() { return h; }
  
  final public int area() { return w*h; }
  
  final public int x() { return x; }
  final public int y() { return y; }
  
  WidthAndHeight widthAndHeight() { return main.widthAndHeight(w, h); }
}
static class ProgramScan {
  static int threads = isWindows() ? 500 : 10;
  static int timeout = 5000; // hmm...
  static String ip = "127.0.0.1";
  
  // This range is not used anymore anyway
  static int quickScanFrom = 10000, quickScanTo = 10999;

  static int maxNumberOfVMs_android = 4; // Android will always only have one if we don't screw up
  static int maxNumberOfVMs_nonAndroid = 50; // 100;
  static int maxNumberOfVMs;
  
  static boolean verbose = false;
  
  static class Program {
    int port;
    String helloString;
    
    Program(int port, String helloString) {
  this.helloString = helloString;
  this.port = port;}
  }
  
  static List<Program> scan() { try {
    return scan(1, 65535);
  } catch (Exception __e) { throw rethrow(__e); } }
  
  static List<Program> scan(int fromPort, int toPort) {
    return scan(fromPort, toPort, new int[0]);
  }
  
  static List<Program> scan(int fromPort, int toPort, int[] preferredPorts) { try {
    Set<Integer> preferredPortsSet = new HashSet<Integer>(asList(preferredPorts));
    int scanSize = toPort-fromPort+1;
    String name = toPort < 10000 ? "bot" : "program";
    int threads = isWindows() ? min(500, scanSize) : min(scanSize, 10);
    final ExecutorService es = Executors.newFixedThreadPool(threads);
    if (verbose) print(firstToUpper(name) + "-scanning " + ip + " with timeout " + timeout + " ms in " + threads + " threads.");
    startTiming();
    List<Future<Program>> futures = new ArrayList();
    List<Integer> ports = new ArrayList();
    for (int port : preferredPorts) {
      futures.add(checkPort(es, ip, port, timeout));
      ports.add(port);
    }
    for (int port = fromPort; port <= toPort; port++)
      if (!preferredPortsSet.contains(port) && !forbiddenPort(port)) {
        futures.add(checkPort(es, ip, port, timeout));
        ports.add(port);
      }
    es.shutdown();
    List<Program> programs = new ArrayList();
    long time = now();
    int i = 0;
    for (final Future<Program> f : futures) {
      if (verbose) print("Waiting for port " + get(ports, i++) + " at time " + (now()-time));
      Program p = f.get();
      if (p != null)
        programs.add(p);
    }
    //stopTiming("Port Scan " + scanSize + ", " + n(threads, "threads") + ": ", 250);
    if (verbose) print("Found " + programs.size() + " " + name + "(s) on " + ip);
    return programs;
  } catch (Exception __e) { throw rethrow(__e); } }

  static Future<Program> checkPort(final ExecutorService es, final String ip, final int port, final int timeout) {
    return es.submit(new Callable<Program>() {
        @Override public Program call() {
          try {
            Socket socket = new Socket();
            try {
              socket.setSoTimeout(timeout);
              socket.connect(new InetSocketAddress(ip, port), timeout);
              //if (verbose) print("Connected to " + ip + ":" + port);
              BufferedReader in = new BufferedReader(
                new InputStreamReader(socket.getInputStream(), "UTF-8"));
              String hello = or(in.readLine(), "?");
              return new Program(port, hello);
            } finally {
              socket.close();
            }
          } catch (Exception ex) {
            return null;
          }
        }
     });
  }
  
  static List<Program> quickScan() {
    return scan(quickScanFrom, quickScanTo);
  }
  
  static List<Program> quickBotScan() {
    return quickBotScan(new int[0]);
  }
  
  static List<Program> quickBotScan(int[] preferredPorts) {
    if (maxNumberOfVMs == 0)
      maxNumberOfVMs = isAndroid() ? maxNumberOfVMs_android : maxNumberOfVMs_nonAndroid;
    return scan(4999, 5000+maxNumberOfVMs-1, preferredPorts);
  }
}
static class Pt implements Comparable<Pt>, IDoublePt {
  int x, y;
  
  Pt() {}
  Pt(Point p) {
    x = p.x;
    y = p.y;
  }
  Pt(int x, int y) {
  this.y = y;
  this.x = x;}
  
  Point getPoint() {
    return new Point(x, y);
  }
  
  public boolean equals(Object o) {
    return o instanceof Pt && x == ((Pt) o).x && y == ((Pt) o).y;
  }
  
  public int hashCode() {
    return boostHashCombine(x, y);
  }
  
  // compare in scan order
  public int compareTo(Pt p) {
    if (y != p.y) return cmp(y, p.y);
    return cmp(x, p.x);
  }
  
  public String toString() {
    return x + ", " + y;
  }
  
  double length() { return sqrt(x*x+y*y); }
  
  public Pt minus(Pt p) { return ptMinus(this, p); }
  
  public double x_double() { return x; }
  public double y_double() { return y; }
}
// could almost add IVar<A> here - but void set() and bool set() are incompatible in some places
static interface IRef<A> extends IF0<A> {
  // called by the referencee to atomically replace itself
  // Passing oldValue to avoid race conditions
  public default void replaceValue(A oldValue, A newValue) {}
}
static abstract class F0<A> {
  abstract A get();
}
static abstract class F1<A, B> {
  abstract B get(A a);
}
// you still need to implement hasNext() and next()
static abstract class IterableIterator<A> implements Iterator<A>, Iterable<A> {
  public Iterator<A> iterator() {
    return this;
  }
  
  public void remove() {
    unsupportedOperation();
  }
}
static class Flag implements Runnable {
  private volatile boolean up = false;

  /** returns true if flag was down before (i.e. flag was actually raised right now) */
  public boolean raise() {
    if (up) return false;
    synchronized(this) {
      if (up) return false;
      up = true;
      notifyAll();
      return true;
    }
  }

  public void run() { try { raise(); } catch (Exception __e) { throw rethrow(__e); } }
  
  public void waitUntilUp() { try {
    if (up) return;
    synchronized(this) {
      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 boolean waitUntilUp(long timeout) { try {
    if (up) return true;
    synchronized(this) {
      if (!up)
        wait(timeout);
    }
    return isUp();
  } catch (Exception __e) { throw rethrow(__e); } }

  final public boolean get(){ return isUp(); }
public boolean isUp() { return up; }

  public String toString() { return isUp() ? "up" : "down"; }
}
interface PCallPolicy {
  void handlePcallFail(Throwable e);
}
public static interface IF0<A> {
  A get();
}
static interface Hasher<A> {
  int hashCode(A a);
  boolean equals(A a, A b);
}
static abstract class CloseableIterableIterator<A> extends IterableIterator<A> implements AutoCloseable {
  public void close() throws Exception {}
}
static class ConceptFieldIndexCI<A extends Concept>  extends ConceptFieldIndexBase<A, Object> {
  ConceptFieldIndexCI(Class<A> cc, String field) { super(cc, field); }
  ConceptFieldIndexCI(Concepts concepts, Class<A> cc, String field) { super(concepts, cc, field); }

  void init() {
    valueToObject = generalizedCIMultiSetMap();
  }
  
  void register() {
    concepts.addCIFieldIndex(cc, field, this);
  }
}
static interface IF2<A, B, C> {
  C get(A a, B b);
}
static interface Producer<A> {
  public A next(); // null when end
}
static interface IF1<A, B> {
  B get(A a);
}
static interface IVF1<A> {
  void get(A a);
}
static class ServeHttp_CookieHandler {
  int days = 365;
  String cookieName = "cookie";
  boolean verbose = false;
  String cookieValue;
  String metaParams; // e.g. "SameSite=Strict"
  boolean shareCookiesBetweenApexDomains = false;

  // returns cookie (may be empty if client doesn't accept cookies)
  String handle() {
    NanoHTTPD.IHTTPSession session = NanoHTTPD.currentSession.get();
    if (session == null) return null;
    NanoHTTPD.CookieHandler cookies = session.getCookies();
    if (empty(cookieValue)) cookieValue = cookies.read("cookie");
    String existingValue = cookieValue;
    var headers= session.getHeaders();
    if (empty(cookieValue) && empty((String) mapGet(headers, "x-no-cookies"))) {
      cookieValue = createNewCookie();
      if (verbose)
        print("New cookie.");
    }
    
    if (verbose)
      print("IP " + session.remoteIp() + ", cookie: " + cookieValue);
      
    if (!eq_nullIfEmpty(existingValue, cookieValue)) {
      var cookie = cookies.set("cookie", cookieValue + prependIfNempty("; ", metaParams), days);
      
      String apexDomain = apexDomain(dropPortFromHost(session.getHeaders().get("host")));
      if (shareCookiesBetweenApexDomains && nempty(apexDomain))
        cookie.domain = apexDomain;
    }

    return cookieValue; 
  }
  
  transient  IF0<String> createNewCookie;
String createNewCookie() { return createNewCookie != null ? createNewCookie.get() : createNewCookie_base(); }
final String createNewCookie_fallback(IF0<String> _f) { return _f != null ? _f.get() : createNewCookie_base(); }
String createNewCookie_base() {
    return randomID(20);
  }
}
static interface IVF2<A, B> {
  void get(A a, B b);
}
// immutable, has strong refs
// Do not run in a synchronized block - it goes wrong in the presence
// of elaborate classloaders (like in Gazelle BEA)
// see #1102990 and #1102991

final static class _MethodCache {
  final Class c;
  final HashMap<String, List<Method>> cache = new HashMap();
  
  _MethodCache(Class c) {
  this.c = c; _init(); }
  
  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();
    }
    
    // add default methods - this might lead to a duplication
    // because the overridden method is also added, but it's not
    // a problem except for minimal performance loss.
    // If any classes in the hierarchy were inaccessible, we add
    // all interface methods (see test_callForbiddenMethodByReflection for a test)
    
    for (Class intf : allInterfacesImplementedBy(c))
      for (Method m : intf.getDeclaredMethods())
        if ((anyHiddenClasses || m.isDefault()) && !reflection_isForbiddenMethod(m))
          multiMapPut(cache, m.getName(), makeAccessible(m));

     
  }
  
  // Returns only matching methods
  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); } }
  
  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); } }
  
  //Cl<Method> allMethods() { ret allValues(cache); }
}


// for sub-bots
static class WebSocketWithWebRequest extends WebSocket {
  WebRequest request;
  
  WebSocketWithWebRequest(NanoHTTPD.IHTTPSession session, WebRequest request) {
    super(session);
  this.request = request;
  }
  
  IWebRequest webRequest() { return request; }
}

static class WebRequest implements IWebRequest {
  NanoHTTPD.IHTTPSession httpSession;
  String uri, subURI;
  Map<String, String> params, files;
  String cookie, clientIP;
  Session session;
  boolean isHttps, noSpam;
  
  WebRequest(NanoHTTPD.IHTTPSession httpSession, String uri, Map<String, String> params) {
  this.params = params;
  this.uri = uri;
  this.httpSession = httpSession;
    files = httpSession.getFiles();
    clientIP =  getClientIPFromHeaders(httpSession.getHeaders());
  }
  
  public String uri() { return uri; }
  public Map<String, String> params() { return params; }
  public Map<String, String> files() { return files; }
  
  public Map<String, String> headers() { return httpSession.getHeaders(); }
  
  public String cookie() { return cookie; }
  
  public boolean isHttps() { return isHttps; }
  
  public boolean isPost() { return httpSession.getMethod() == NanoHTTPD.Method.POST; }
  
  User loggedInUser() {
    return session == null ? null : session.user();
  }
  
  String googleClientID() {
    String domain = lower(domain());
    File jsonFile = googleClientSecretFileForDomain(domain);
    if (!fileExists(jsonFile)) return null;
    
    Map map = decodeJSONMap(loadTextFile(jsonFile));
    map = (Map) map.get("web");
    return (String) map.get("client_id");
  }
  
  public void noSpam() {
    if (noSpam) return;
    noSpam = true;
    print("noSpam count: " + simpleSpamClientDetect2_markNoSpam(clientIP, uri) + " (" + clientIP + "/" + uri + ")");
  }
}

static class User extends ConceptWithGlobalID {
  long lastSeen;
}

static class CookieUser extends User {
  String cookie;

  public String toString() { return "[cookieUser " + md5(cookie) + "]"; }
}

static class GoogleUser extends User {
  static final String _fieldOrder = "googleLogInDate googleEmail googleFirstName googleLastName googleEmailVerified";
  long googleLogInDate;
  String googleEmail, googleFirstName, googleLastName;
  boolean googleEmailVerified = false;

  public String toString() { return googleFirstName + " " + googleLastName; }
}

static class Session extends Concept {
  static final String _fieldOrder = "cookie user accesses";
  String cookie;
  User user;
  long accesses;
  
  User user() {
    if (user == null)
      cset(this, "user" , uniq(CookieUser.class, "cookie", cookie));
    return user;
  }
}

abstract static class DynEleu extends DynPrintLogAndEnabled {
  
// needs a function O webServe(S uri, SS params) { ... }
// and a function newWebSocket()

static boolean _switchableField_httpPort = true; int httpPort = 80;
static boolean _switchableField_httpsPort = true; int httpsPort = 443;
void cleanMeUp_httpServer() { { cleanUp(httpServer); httpServer = null; } } transient  WebSocketHTTPD httpServer;
void cleanMeUp_httpsServer() { { cleanUp(httpsServer); httpsServer = null; } } transient  WebSocketHTTPD httpsServer;
static boolean _switchableField_redirectHttpToHttps = true; boolean redirectHttpToHttps = false;

transient HTTPSpamBlocker1 spamBlocker = new HTTPSpamBlocker1();

void start_webServers(File keyStore, String passphrase) {
  start_webServers(serveHttps_makeSSLSocketFactory(keyStore, passphrase));
}

void start_webServers(SSLServerSocketFactory sslSocketFactory) { try {
  if (httpPort != 0) { try {
    WebSocketHTTPD _httpServer = new WebSocketHTTPD(httpPort, __69 -> newWebSocket(__69));
    _httpServer.enter = () -> enter();
    _httpServer.serveFunction = new F2<String, Map<String, String>, Object>() { public Object get(String uri, Map<String, String> parms) { try { 
      return redirectHttpToHttps && !startsWith(uri, "/.well-known/")
        ? serveRedirect("https://" + serveHttp_domainName()
          + (httpsPort == 443 ? "" : ":" + httpsPort) + uri)
        : webServe(uri, parms);
     } catch (Exception __e) { throw rethrow(__e); } }
  public String toString() { return "redirectHttpToHttps && !startsWith(uri, \"/.well-known/\")\r\n        ? serveRedi..."; }};
    _httpServer.start();
    print("HTTP server started on port " + _httpServer.getPort());
    httpServer = _httpServer;
  } catch (Throwable __e) { pcallFail(__e); }}
  
  if (httpsPort == 0 || sslSocketFactory == null) return;
  try {
    WebSocketHTTPD _httpsServer = new WebSocketHTTPD(httpsPort, __70 -> newWebSocket(__70));
    _httpsServer.enter = () -> enter();
    _httpsServer.makeSecure(sslSocketFactory);
    _httpsServer.serveFunction = new F2<String, Map<String, String>, Object>() { public Object get(String uri, Map<String, String> parms) { try {  return webServe(uri, parms);  } catch (Exception __e) { throw rethrow(__e); } }
  public String toString() { return "webServe(uri, parms)"; }};
    _httpsServer.start();
    print("HTTPS server started on port " + _httpsServer.getPort());
    httpsServer = _httpsServer;
  } catch (Throwable __e) { pcallFail(__e); }
} catch (Exception __e) { throw rethrow(__e); } }

Collection<WebSocketHTTPD> webServers() { return llNotNulls(httpServer, httpsServer); }
double clearSessionsInterval = 60.0;
  double clearSessionsTimeout = 300.0;
  static boolean _switchableField_maxModuleReloadWait = true; double maxModuleReloadWait = 20.0;
  static boolean _switchableField_strayWebSocketDelay = true; double strayWebSocketDelay = 5.0;
  
  // Eleu-wide sessions... I don't think anyone uses these anymore
  static boolean _switchableField_useSessions = true; boolean useSessions = false;
  
  static boolean _switchableField_shareCookiesBetweenApexDomains = true; boolean shareCookiesBetweenApexDomains = true;
  
  // for noticing certificate changes in JavaX-Secret
  transient FileWatchService watchService;
  
  void start() {
    super.start();
    dbIndexing(Session.class, "cookie", CookieUser.class, "cookie", GoogleUser.class, "googleEmail");
    dm_restartOnFieldChange("enabled");
    if (!enabled) return;
    dm_startThread("Start Web Servers", new Runnable() {  public void run() { try { 
      start_webServers(serverSocketFactory_botCompanyEtc());
      onWebServersStarted();
    
} catch (Exception __e) { throw rethrow(__e); } }  public String toString() { return "start_webServers(serverSocketFactory_botCompanyEtc());\r\n      onWebServersSta..."; }});
    dm_doEvery(clearSessionsInterval, new Runnable() {  public void run() { try {  clearSessions(); 
} catch (Exception __e) { throw rethrow(__e); } }  public String toString() { return "clearSessions();"; }});
    
    ownResource(serverSocketFactory_autoUpdate());
  }
  
  void clearSessions() {
    Collection<Session> l = filter(list(Session.class),
      s -> s.accesses <= 1 && elapsedSeconds_timestamp(s.created) >= clearSessionsTimeout);
    if (nempty(l)) {
      print("Dropping " + nSessions(l));
      deleteConcepts(l);
    }
  }
  
  WebSocket newWebSocket(NanoHTTPD.IHTTPSession handshake) {  AutoCloseable __1 = enter(); try {
    vmBus_send("haveNewWebSocket", module(), handshake);
    String domain = mapGet(handshake.getHeaders(), "host");
    String uri = handshake.getUri();
    Map<String, String> params = handshake.getParms();
    print("Making WebSocket. domain: " + domain + ", uri: " + uri);
    WebRequest req = createWebRequest(handshake, uri, params);
    WebSocket ws = new WebSocketWithWebRequest(handshake, req);
    
    String module = moduleForDomainAndURI(domain, uri);
    if (nempty(module) && !dm_moduleIsStartingOrReloading(module)) { try {
      dm_callOpt(module, "handleWebSocket", ws);
    } catch (Throwable __e) { pcallFail(__e); }} else {
      sleepSeconds(strayWebSocketDelay);
      ws.close(); // Hopefully just a reload
    }
      
    return ws;
  } finally { _close(__1); }}
  
  Object webServe(String uri, Map<String, String> params) {
    WebRequest req = new WebRequest(NanoHTTPD.currentSession.get(), uri, params);
    print("IP: " + req.clientIP);
    
    Pair<Integer, Boolean> spamCheck = spamBlocker.checkRequest(req.uri, req.clientIP);
    if (spamCheck.b) {
      print("Request from blocked IP: " + req.clientIP);
      sleepSeconds(60.0);
      return print("go away");
    }

    // fill more fields of WebRequest
    
    fillWebRequest(req);
    
    // log some
    
    printVars("webServe", "uri", uri, "userAgent" , req.userAgent());
    
    // Serve Let's encrypt challenges
    
    if (startsWith(uri, "/.well-known/")) {
      String fileName = "validation.txt";
      /*if (swic(req.domain(), "www."))
        fileName = "validation-www.txt";*/
      return loadTextFile(userDir(fileName));
    }
      
    // Serve Google verification
    
    
    if (eqic(uri, "/google-verify"))
      return serveGoogleVerify(req);
    
      
    String module = moduleForDomainAndURI(req.domain(), uri);
    if (nempty(module)) {
      if (sleepWhile(() -> dm_moduleIsStartingOrReloading(module), "max" , maxModuleReloadWait))
        return subBot_serve500("Reload taking too long");
      return eleu_callModuleHTMLMethod(module, req);
    }
    
    return subBot_serve404();
  }

  // override me
  String moduleForDomain(String domain) { return null; }
  
  // or me
  String moduleForDomainAndURI(String domain, String uri) { return moduleForDomain(domain); }

  
  Object serveGoogleVerify(WebRequest req) {
    Payload payload = googleVerifyUserToken2(req.googleClientID(), req.params.get("token"));
    String email = payload == null ? null : payload.getEmail();
    if (empty(email)) return print("google-verify", "No");
    
    // create/update an object for the user
    GoogleUser user = uniqCI_sync(GoogleUser.class, "googleEmail" , email);
    cset(user,
      "googleEmailVerified" , payload.getEmailVerified(),
      "googleFirstName" , strOrNull(payload.get("given_name")),
      "googleLastName" , strOrNull(payload.get("family_name")),
      "googleLogInDate" , now());
    
    // link user to session
    cset(req.session, "user", user);
      
    return print("google-verify", payload.getEmail() + " " + (payload.getEmailVerified() ? "(verified)" : "(not verified)"));
  }
  

  ServeHttp_CookieHandler makeCookieHandler() {
    ServeHttp_CookieHandler h = new ServeHttp_CookieHandler();
    h.verbose = true;
    h.shareCookiesBetweenApexDomains = shareCookiesBetweenApexDomains;
    return h;
  }

  void fillWebRequest(WebRequest req) {  
    req.cookie = makeCookieHandler().handle();
    
    req.isHttps = WebSocketHTTPD_current.get() == httpsServer;
    
    // Get session
    req.session = nempty(req.cookie) && useSessions ? uniq(Session.class, "cookie" , req.cookie) : null;
    if (req.session != null)
      cset(req.session, "accesses" , req.session.accesses+1);
    print("session" , req.session);
  }
  
  void enhanceFrame(Container c) {
    super.enhanceFrame(c);
    internalFrameMenuItem(c, "Show blocked IPs", runnableThread(new Runnable() {  public void run() { try {   AutoCloseable __2 = enter(); try { 
      print("Blocked IPs: " + spamBlocker.blockedIPs);
    
} finally { _close(__2); }} catch (Exception __e) { throw rethrow(__e); } }  public String toString() { return "temp enter(); \r\n      print(\"Blocked IPs: \" + spamBlocker.blockedIPs);"; }}));
  }

  void onWebServersStarted() {}
  
  WebRequest createWebRequest(NanoHTTPD.IHTTPSession httpSession,
    String uri, Map<String, String> params) {
    return new WebRequest(httpSession, uri, params);
  }
} // end of module
static class Matches {
  String[] m;
  
  Matches() {}
  Matches(String... m) {
  this.m = m;}
  
  String get(int i) { return i < m.length ? m[i] : null; }
  String unq(int i) { return unquote(get(i)); }
  
  String tlc(int i) { return unq(i).toLowerCase(); }
  boolean bool(int i) { return "true".equals(unq(i)); }
  String rest() { return m[m.length-1]; } // for matchStart
  int psi(int i) { return Integer.parseInt(unq(i)); }
  
  public String toString() { return "Matches(" + joinWithComma(quoteAll(asList(m))) + ")"; }
  
  public int hashCode() { return _hashCode(toList(m)); }
  public boolean equals(Object o) { return o instanceof Matches && arraysEqual(m, ((Matches) o).m); }
}

// for the version with MasterSymbol (used WAY back in "Smart Bot"!) see #1010608

static class Symbol implements CharSequence {
  String text;
  
  Symbol() {}
  Symbol(String text, boolean dummy) {
  this.text = text;} // weird signature to prevent accidental calling
  
  public int hashCode() { return _hashCode(text); }
  public String toString() { return text; }
  public boolean equals(Object o) {
    return this == o;
  }

  // implementation of CharSequence methods
  
  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 interface IMeta {
  // see class "Meta" for the bla bla
  
  public void _setMeta(Object meta);
  public Object _getMeta();
  default public IAutoCloseableF0 _tempMetaMutex() {
    return new IAutoCloseableF0() {
      public Object get() { return IMeta.this; }
      public void close() {}
    };
  }
  
  // actually query another object
  default public Object getMeta(Object obj, Object key){ return metaGet(obj, key); }
default public Object metaGet(Object obj, Object key) {
    // call global function
    return metaMapGet(obj, key);
  }
  
  default public Object metaGet(String key, Object obj) {
    // call global function
    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) {
    // call global function
    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);
  }
}
// a variant of thread where you can get the Runnable target later.
// Also notes its existence on the VM bus.
// We should use this exclusively instead of Thread.

static class BetterThread extends Thread {
  Runnable target;
  
  BetterThread(Runnable target) {
  this.target = target; _created(); }
  BetterThread(Runnable target, String name) { super(name);
  this.target = target; _created(); }
  
  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); } }
  
  Runnable getTarget() { return target; }
}
// not changed yet: allow cookie to be read right after being set

















static boolean NanoHTTPD_debug = false;

static abstract class NanoHTTPD implements AutoCloseable {

    boolean decodePercentInURI = false; // I set this to false, makes more sense to me
    boolean noQueryStringParameter = true;
    
    boolean collectHeaderLines = false;

    static ThreadLocal<IHTTPSession> currentSession = new ThreadLocal<IHTTPSession>();
    
    static List<IHTTPSession> badClients = synchroList();

    /**
     * Pluggable strategy for asynchronously executing requests.
     */
    public interface AsyncRunner {

        void closeAll();

        void closed(ClientHandler clientHandler);

        void exec(ClientHandler code);
    }

    /**
     * The runnable that will be used for every new client connection.
     */
    public class ClientHandler implements Runnable {

        private final InputStream inputStream;
        OutputStream outputStream;

        final Socket acceptSocket;
        
        boolean specialHandler = false;

        private ClientHandler(InputStream inputStream, Socket acceptSocket) {
            this.inputStream = inputStream;
            this.acceptSocket = acceptSocket;
        }

        public void close() {
          if (NanoHTTPD_debug) printVars("ClientHandler.close", "specialHandler", specialHandler);
          if (specialHandler) return;
          safeClose(this.outputStream);
          safeClose(this.inputStream);
          safeClose(this.acceptSocket);
        }

        @Override
        public void run() {
            try {
                //outputStream = wrapStuff("SocketOutputStream", this.acceptSocket.getOutputStream(), this.acceptSocket);
                outputStream = this.acceptSocket.getOutputStream();
                TempFileManager tempFileManager = NanoHTTPD.this.tempFileManagerFactory.create();
                HTTPSession session = new HTTPSession(tempFileManager, acceptSocket, this.inputStream, outputStream, this.acceptSocket.getInetAddress());
                if (NanoHTTPD_debug) print("NanoHTTPD: Have session");
                while (!this.acceptSocket.isClosed() && !session.badClient) {
                    if (NanoHTTPD_debug) print("session execute");
                    session.execute();
                    if (NanoHTTPD_debug) print("specialHandler" , session.specialHandler);
                    if (session.specialHandler)
                      { specialHandler = true; return; }
                }
            } catch (Exception e) {
                // When the socket is closed by the client,
                // we throw our own SocketException
                // to break the "keep alive" loop above. If
                // the exception was anything other
                // than the expected SocketException OR a
                // SocketTimeoutException, print the
                // stacktrace
                print("NanoHTTPD: Error " + e);

                if (!(e instanceof SocketException && "NanoHttpd Shutdown".equals(e.getMessage())) && !(e instanceof SocketTimeoutException)) {
                    NanoHTTPD.LOG.log(Level.FINE, "Communication with the client broken", e);
                }
            } finally {
              close(); 
              
              NanoHTTPD.this.asyncRunner.closed(this);
              if (NanoHTTPD_debug) print("NanoHTTPD: finally branch done");
            }
        }
    }

    public static class Cookie {

        public static String getHTTPTime(int days) {
            Calendar calendar = Calendar.getInstance();
            SimpleDateFormat dateFormat = new SimpleDateFormat("EEE, dd MMM yyyy HH:mm:ss z", Locale.US);
            dateFormat.setTimeZone(TimeZone.getTimeZone("GMT"));
            calendar.add(Calendar.DAY_OF_MONTH, days);
            return dateFormat.format(calendar.getTime());
        }

        final String n, v, e;
        String domain, path;

        public Cookie(String name, String value) {
            this(name, value, 30);
        }

        public Cookie(String name, String value, int numDays) {
            this.n = name;
            this.v = value;
            this.e = getHTTPTime(numDays);
        }

        public Cookie(String name, String value, String expires) {
            this.n = name;
            this.v = value;
            this.e = expires;
        }

        public String getHTTPHeader() {
          StringBuilder buf = new StringBuilder();
            buf.append(n).append("=").append(v).append("; expires=").append(e);
          if (nempty(domain)) buf.append("; Domain=").append(domain);
          if (nempty(path)) buf.append("; Path=").append(path);
          return buf.toString();
        }
    }

    /**
     * Provides rudimentary support for cookies. Doesn't support 'path',
     * 'secure' nor 'httpOnly'. Feel free to improve it and/or add unsupported
     * features.
     * 
     * @author LordFokas
     */
    public class CookieHandler implements Iterable<String> {

        private final HashMap<String, String> cookies = new HashMap<String, String>();

        private final ArrayList<Cookie> queue = new ArrayList<Cookie>();

        public CookieHandler(Map<String, String> httpHeaders) {
            String raw = httpHeaders.get("cookie");
            if (raw != null) {
                String[] tokens = raw.split(";");
                for (String token : tokens) {
                    String[] data = token.trim().split("=");
                    if (data.length == 2) {
                        this.cookies.put(data[0], data[1]);
                    }
                }
            }
        }

        /**
         * Set a cookie with an expiration date from a month ago, effectively
         * deleting it on the client side.
         * 
         * @param name
         *            The cookie name.
         */
        public void delete(String name) {
            set(name, "-delete-", -30);
        }

        @Override
        public Iterator<String> iterator() {
            return this.cookies.keySet().iterator();
        }

        /**
         * Read a cookie from the HTTP Headers.
         * 
         * @param name
         *            The cookie's name.
         * @return The cookie's value if it exists, null otherwise.
         */
        public String read(String name) {
            return this.cookies.get(name);
        }

        public void set(Cookie cookie) {
            this.queue.add(cookie);
            //cookies.put(cookie.n, cookie.v); // CHANGED
        }

        /**
         * Sets a cookie.
         * 
         * @param name
         *            The cookie's name.
         * @param value
         *            The cookie's value.
         * @param expires
         *            How many days until the cookie expires.
         */
        public Cookie set(String name, String value, int expires) {
            return addAndReturn(this.queue, new Cookie(name, value, Cookie.getHTTPTime(expires)));
        }

        /**
         * Internally used by the webserver to add all queued cookies into the
         * Response's HTTP Headers.
         * 
         * @param response
         *            The Response object to which headers the queued cookies
         *            will be added.
         */
        public void unloadQueue(Response response) {
            for (Cookie cookie : this.queue) {
                response.addHeader("Set-Cookie", cookie.getHTTPHeader());
            }
        }
    }

    /**
     * Default threading strategy for NanoHTTPD.
     * <p/>
     * <p>
     * By default, the server spawns a new Thread for every incoming request.
     * These are set to <i>daemon</i> status, and named according to the request
     * number. The name is useful when profiling the application.
     * </p>
     */
    public static class DefaultAsyncRunner implements AsyncRunner {

        private long requestCount;

        private final List<ClientHandler> running = Collections.synchronizedList(new ArrayList<NanoHTTPD.ClientHandler>());

        /**
         * @return a list with currently running clients.
         */
        public List<ClientHandler> getRunning() {
            return running;
        }

        @Override
        public void closeAll() {
            // copy of the list for concurrency
            for (ClientHandler clientHandler : new ArrayList<ClientHandler>(this.running)) {
                clientHandler.close();
            }
        }

        @Override
        public void closed(ClientHandler clientHandler) {
            this.running.remove(clientHandler);
        }

        @Override
        public void exec(ClientHandler clientHandler) {
            ++this.requestCount;
            Thread t = new Thread(clientHandler);
            //t.setDaemon(true);
            String clientIP = "?";
            try { clientIP = clientHandler.acceptSocket.getInetAddress().getHostAddress().toString(); } catch (Throwable __e) { pcallFail(__e); }
            t.setName("NanoHttpd serving request #" + this.requestCount + " to " + clientIP);
            this.running.add(clientHandler);
            t.start();
        }
    }

    /**
     * Default strategy for creating and cleaning up temporary files.
     * <p/>
     * <p>
     * By default, files are created by <code>File.createTempFile()</code> in
     * the directory specified.
     * </p>
     */
    public static class DefaultTempFile implements TempFile {

        private final File file;

        private final OutputStream fstream;

        public DefaultTempFile(String tempdir) throws IOException {
            this.file = File.createTempFile("NanoHTTPD-", "", new File(tempdir));
            this.fstream = new FileOutputStream(this.file);
            System.err.println("Temp file created: " + file);
        }

        @Override
        public void delete() throws Exception {
            safeClose(this.fstream);
            System.err.println("Temp file deleted: " + file);
            if (!this.file.delete()) {
                throw new Exception("could not delete temporary file");
            }
        }

        @Override
        public String getName() {
            return this.file.getAbsolutePath();
        }

        @Override
        public OutputStream open() throws Exception {
            return this.fstream;
        }
    }

    /**
     * Default strategy for creating and cleaning up temporary files.
     * <p/>
     * <p>
     * This class stores its files in the standard location (that is, wherever
     * <code>java.io.tmpdir</code> points to). Files are added to an internal
     * list, and deleted when no longer needed (that is, when
     * <code>clear()</code> is invoked at the end of processing a request).
     * </p>
     */
    public static class DefaultTempFileManager implements TempFileManager {

        private final String tmpdir;

        private final List<TempFile> tempFiles;

        public DefaultTempFileManager() {
            this.tmpdir = tempDir().getPath(); // use JavaX, dude
              // System.getProperty("java.io.tmpdir");
            this.tempFiles = new ArrayList<TempFile>();
        }

        @Override
        public void clear() {
            for (TempFile file : this.tempFiles) {
                try {
                    file.delete();
                } catch (Exception ignored) {
                    NanoHTTPD.LOG.log(Level.WARNING, "could not delete file ", ignored);
                }
            }
            this.tempFiles.clear();
        }

        @Override
        public TempFile createTempFile() throws Exception {
            DefaultTempFile tempFile = new DefaultTempFile(this.tmpdir);
            this.tempFiles.add(tempFile);
            return tempFile;
        }
    }

    /**
     * Default strategy for creating and cleaning up temporary files.
     */
    private class DefaultTempFileManagerFactory implements TempFileManagerFactory {

        @Override
        public TempFileManager create() {
            return new DefaultTempFileManager();
        }
    }

    private static final String CONTENT_DISPOSITION_REGEX = "([ |\t]*Content-Disposition[ |\t]*:)(.*)";

    private static final Pattern CONTENT_DISPOSITION_PATTERN = Pattern.compile(CONTENT_DISPOSITION_REGEX, Pattern.CASE_INSENSITIVE);

    private static final String CONTENT_TYPE_REGEX = "([ |\t]*content-type[ |\t]*:)(.*)";

    private static final Pattern CONTENT_TYPE_PATTERN = Pattern.compile(CONTENT_TYPE_REGEX, Pattern.CASE_INSENSITIVE);

    private static final String CONTENT_DISPOSITION_ATTRIBUTE_REGEX = "[ |\t]*([a-zA-Z]*)[ |\t]*=[ |\t]*['|\"]([^\"^']*)['|\"]";

    private static final Pattern CONTENT_DISPOSITION_ATTRIBUTE_PATTERN = Pattern.compile(CONTENT_DISPOSITION_ATTRIBUTE_REGEX);

    class HTTPSession implements IHTTPSession {
    
        boolean badClient = false;
        boolean specialHandler = false; // we handle the request outside of NanoHTTPD
        
        long opened = sysNow();

        public static final int BUFSIZE = 8192;

        private final TempFileManager tempFileManager;
        
        private Socket socket;

        private final OutputStream outputStream;

        private final PushbackInputStream inputStream;

        private int splitbyte;

        private int rlen;

        private String uri;

        private Method method;

        private Map<String, String> parms;

        private Map<String, String> headers;

        Map<String, String> files = new HashMap();
        
        private CookieHandler cookies;

        private String queryParameterString;

        private String remoteIp;

        private String protocolVersion;
        
        private String fullURI;
        
        List<String> headerLines = collectHeaderLines ? new ArrayList() : null;

        public HTTPSession(TempFileManager tempFileManager,
          Socket socket, InputStream inputStream, OutputStream outputStream) {
            this.socket = socket;
            this.tempFileManager = tempFileManager;
            this.inputStream = new PushbackInputStream(inputStream, HTTPSession.BUFSIZE);
            this.outputStream = outputStream;
        }
        
        public String getProtocolVersion() { return protocolVersion; }
        public String getFullURI() { return fullURI; }
        
        public List<String> getHeaderLines() { return headerLines; }

        public HTTPSession(TempFileManager tempFileManager, Socket socket, InputStream inputStream, OutputStream outputStream, InetAddress inetAddress) {
            this.socket = socket;
            this.tempFileManager = tempFileManager;
            this.inputStream = new PushbackInputStream(inputStream, HTTPSession.BUFSIZE);
            this.outputStream = outputStream;
            this.remoteIp = inetAddress.isLoopbackAddress() || inetAddress.isAnyLocalAddress() ? "127.0.0.1" : inetAddress.getHostAddress().toString();
            this.headers = new LinkedHashMap<String, String>();
        }
        
        public void badClient(boolean b) { badClient = b; }
        public void specialHandler(boolean b) { specialHandler = b; }

        /**
         * Decodes the sent headers and loads the data into Key/value pairs
         */
        private void decodeHeader(BufferedReader in, Map<String, String> pre, Map<String, String> parms, Map<String, String> headers, Map<String, String> files) throws ResponseException {
            try {
                // Read the request line
                String inLine = in.readLine();
                if (inLine == null) {
                    return;
                }

                StringTokenizer st = new StringTokenizer(inLine);
                if (!st.hasMoreTokens()) {
                    throw new ResponseException(Status.BAD_REQUEST, "BAD REQUEST: Syntax error. Usage: GET /example/file.html");
                }

                pre.put("method", st.nextToken());

                if (!st.hasMoreTokens()) {
                    throw new ResponseException(Status.BAD_REQUEST, "BAD REQUEST: Missing URI. Usage: GET /example/file.html");
                }

                String uri = st.nextToken();
                fullURI = uri;

                // Decode parameters from the URI
                int qmi = uri.indexOf('?');
                if (qmi >= 0) {
                    String query = uri.substring(qmi + 1);
                    files.put("query", query);
                    decodeParms(query, parms);
                    uri = uri.substring(0, qmi);
                }
                
                if (decodePercentInURI)
                  uri = decodePercent(uri);

                // If there's another token, its protocol version,
                // followed by HTTP headers.
                // NOTE: this now forces header names lower case since they are
                // case insensitive and vary by client.
                if (st.hasMoreTokens()) {
                    protocolVersion = st.nextToken();
                } else {
                    protocolVersion = "HTTP/1.1";
                    NanoHTTPD.LOG.log(Level.FINE, "no protocol version specified, strange. Assuming HTTP/1.1.");
                }
                String line = in.readLine();
                while (line != null && line.trim().length() > 0) {
                    { if (headerLines != null) headerLines.add(line); }
                    int p = line.indexOf(':');
                    if (p >= 0) {
                        headers.put(line.substring(0, p).trim().toLowerCase(Locale.US), line.substring(p + 1).trim());
                    }
                    line = in.readLine();
                }

                pre.put("uri", uri);
            } catch (IOException ioe) {
                throw new ResponseException(Status.INTERNAL_ERROR, "SERVER INTERNAL ERROR: IOException: " + ioe.getMessage(), ioe);
            }
        }

        /**
         * Decodes the Multipart Body data and put it into Key/Value pairs.
         */
        private void decodeMultipartFormData(String boundary, java.nio.ByteBuffer fbuf, Map<String, String> parms, Map<String, String> files) throws ResponseException {
            try {
                int[] boundary_idxs = getBoundaryPositions(fbuf, boundary.getBytes());
                if (boundary_idxs.length < 2) {
                    throw new ResponseException(
                    Status.BAD_REQUEST, "BAD REQUEST: Content type is multipart/form-data but contains less than two boundary strings.");
                }

                final int MAX_HEADER_SIZE = 1024;
                byte[] part_header_buff = new byte[MAX_HEADER_SIZE];
                for (int bi = 0; bi < boundary_idxs.length - 1; bi++) {
                    fbuf.position(boundary_idxs[bi]);
                    int len = (fbuf.remaining() < MAX_HEADER_SIZE) ? fbuf.remaining() : MAX_HEADER_SIZE;
                    fbuf.get(part_header_buff, 0, len);
                    ByteArrayInputStream bais = new ByteArrayInputStream(part_header_buff, 0, len);
                    BufferedReader in = new BufferedReader(new InputStreamReader(bais, Charset.forName("US-ASCII")));

                    // First line is boundary string
                    String mpline = in.readLine();
                    if (!mpline.contains(boundary)) {
                        throw new ResponseException(Status.BAD_REQUEST, "BAD REQUEST: Content type is multipart/form-data but chunk does not start with boundary.");
                    }

                    String part_name = null, file_name = null, content_type = null;
                    // Parse the reset of the header lines
                    mpline = in.readLine();
                    while (mpline != null && mpline.trim().length() > 0) {
                        Matcher matcher = CONTENT_DISPOSITION_PATTERN.matcher(mpline);
                        if (matcher.matches()) {
                            String attributeString = matcher.group(2);
                            matcher = CONTENT_DISPOSITION_ATTRIBUTE_PATTERN.matcher(attributeString);
                            while (matcher.find()) {
                                String key = matcher.group(1);
                                if (key.equalsIgnoreCase("name")) {
                                    part_name = matcher.group(2);
                                } else if (key.equalsIgnoreCase("filename")) {
                                    file_name = matcher.group(2);
                                }
                            }
                        }
                        matcher = CONTENT_TYPE_PATTERN.matcher(mpline);
                        if (matcher.matches()) {
                            content_type = matcher.group(2).trim();
                        }
                        mpline = in.readLine();
                    }

                    // Read the part data
                    int part_header_len = len - (int) in.skip(MAX_HEADER_SIZE);
                    if (part_header_len >= len - 4) {
                        throw new ResponseException(Status.INTERNAL_ERROR, "Multipart header size exceeds MAX_HEADER_SIZE.");
                    }
                    int part_data_start = boundary_idxs[bi] + part_header_len;
                    int part_data_end = boundary_idxs[bi + 1] - 4;

                    fbuf.position(part_data_start);
                    if (content_type == null) {
                        // Read the part into a string
                        byte[] data_bytes = new byte[part_data_end - part_data_start];
                        fbuf.get(data_bytes);
                        parms.put(part_name, new String(data_bytes));
                    } else {
                        // Read it into a file
                        String path = saveTmpFile(fbuf, part_data_start, part_data_end - part_data_start);
                        if (!files.containsKey(part_name)) {
                            files.put(part_name, path);
                        } else {
                            int count = 2;
                            while (files.containsKey(part_name + count)) {
                                count++;
                            }
                            files.put(part_name + count, path);
                        }
                        parms.put(part_name, file_name);
                    }
                }
            } catch (ResponseException re) {
                throw re;
            } catch (Exception e) {
                throw new ResponseException(Status.INTERNAL_ERROR, e.toString());
            }
        }

        /**
         * Decodes parameters in percent-encoded URI-format ( e.g.
         * "name=Jack%20Daniels&pass=Single%20Malt" ) and adds them to given
         * Map. NOTE: this doesn't support multiple identical keys due to the
         * simplicity of Map.
         */
        private void decodeParms(String parms, Map<String, String> p) {
            if (parms == null) {
                this.queryParameterString = "";
                return;
            }

            this.queryParameterString = parms;
            StringTokenizer st = new StringTokenizer(parms, "&");
            while (st.hasMoreTokens()) {
                String e = st.nextToken();
                int sep = e.indexOf('=');
                if (sep >= 0) {
                    p.put(decodePercent(e.substring(0, sep)).trim(), decodePercent(e.substring(sep + 1)));
                } else {
                    p.put(decodePercent(e).trim(), "");
                }
            }
        }

        @Override
        public void execute() throws IOException {
            Response r = null;
            try {
                // Read the first 8192 bytes.
                // The full header should fit in here.
                // Apache's default header limit is 8KB.
                // Do NOT assume that a single read will get the entire header
                // at once!
                byte[] buf = new byte[HTTPSession.BUFSIZE];
                this.splitbyte = 0;
                this.rlen = 0;

                int read = -1;
                try {
                    read = this.inputStream.read(buf, 0, HTTPSession.BUFSIZE);
                } catch (Exception e) {
                    safeClose(this.inputStream);
                    safeClose(this.outputStream);
                    throw new SocketException("NanoHttpd Shutdown");
                }
                if (read == -1) {
                    // socket was been closed
                    safeClose(this.inputStream);
                    safeClose(this.outputStream);
                    throw new SocketException("NanoHttpd Shutdown");
                }
                while (read > 0) {
                    this.rlen += read;
                    this.splitbyte = findHeaderEnd(buf, this.rlen);
                    if (this.splitbyte > 0)
                        break;             
                        
                    if (rlen >= buf.length) {
                      if (NanoHTTPD_debug)
                        printWithIndent("HEADER> ", new String(buf));
                      throw fail("Header too big (" + rlen + " bytes)");
                    }
                    read = this.inputStream.read(buf, this.rlen, HTTPSession.BUFSIZE - this.rlen);
                }

                if (this.splitbyte < this.rlen) {
                    this.inputStream.unread(buf, this.splitbyte, this.rlen - this.splitbyte);
                }

                this.parms = new HashMap<String, String>();
                if (null == this.headers) {
                    this.headers = new HashMap<String, String>();
                } else {
                    this.headers.clear();
                }

                if (null != this.remoteIp) {
                    this.headers.put("remote-addr", this.remoteIp);
                    this.headers.put("http-client-ip", this.remoteIp);
                }

                // Create a BufferedReader for parsing the header.
                BufferedReader hin = new BufferedReader(new InputStreamReader(new ByteArrayInputStream(buf, 0, this.rlen)));

                // Decode the header into parms and header java properties
                Map<String, String> pre = new LinkedHashMap<String, String>();
                decodeHeader(hin, pre, this.parms, this.headers, this.files);

                this.method = Method.lookup(pre.get("method"));
                if (this.method == null) {
                    throw new ResponseException(Status.BAD_REQUEST, "BAD REQUEST: Syntax error.");
                }

                this.uri = pre.get("uri");

                this.cookies = new CookieHandler(this.headers);

                String connection = this.headers.get("connection");
                boolean keepAlive = protocolVersion.equals("HTTP/1.1") && (connection == null || !connection.matches("(?i).*close.*"));

                // Ok, now do the serve()
                r = serve(this);
                
                if (badClient || specialHandler) return;
                
                if (r == null) {
                    throw new ResponseException(Status.INTERNAL_ERROR, "SERVER INTERNAL ERROR: Serve() returned a null response.");
                } else {
                    String acceptEncoding = this.headers.get("accept-encoding");
                    this.cookies.unloadQueue(r);
                    r.setRequestMethod(this.method);
                    r.setGzipEncoding(useGzipWhenAccepted(r) && acceptEncoding != null && acceptEncoding.contains("gzip"));
                    r.setKeepAlive(keepAlive);
                    r.send(this.outputStream);
                }
                if (!keepAlive || "close".equalsIgnoreCase(r.getHeader("connection"))) {
                    throw new SocketException("NanoHttpd Shutdown");
                }
            } catch (SocketException e) {
                // throw it out to close socket object (finalAccept)
                throw e;
            } catch (SocketTimeoutException ste) {
                // treat socket timeouts the same way we treat socket exceptions
                // i.e. close the stream & finalAccept object by throwing the
                // exception up the call stack.
                throw ste;
            } catch (IOException ioe) {
                Response resp = newFixedLengthResponse(Status.INTERNAL_ERROR, NanoHTTPD.MIME_PLAINTEXT, "SERVER INTERNAL ERROR: IOException: " + ioe.getMessage());
                resp.send(this.outputStream);
                safeClose(this.outputStream);
            } catch (ResponseException re) {
                Response resp = newFixedLengthResponse(re.getStatus(), NanoHTTPD.MIME_PLAINTEXT, re.getMessage());
                resp.send(this.outputStream);
                safeClose(this.outputStream);
            } finally {
              if (badClient)
                badClients.add(this);
              else if (!specialHandler)
                safeClose(r);
              this.tempFileManager.clear();
            }
        }

        /**
         * Find byte index separating header from body. It must be the last byte
         * of the first two sequential new lines.
         */
        private int findHeaderEnd(final byte[] buf, int rlen) {
            int splitbyte = 0;
            while (splitbyte + 3 < rlen) {
                if (buf[splitbyte] == '\r' && buf[splitbyte + 1] == '\n' && buf[splitbyte + 2] == '\r' && buf[splitbyte + 3] == '\n') {
                    return splitbyte + 4;
                }
                splitbyte++;
            }
            return 0;
        }

        /**
         * Find the byte positions where multipart boundaries start. This reads
         * a large block at a time and uses a temporary buffer to optimize
         * (memory mapped) file access.
         */
        private int[] getBoundaryPositions(java.nio.ByteBuffer b, byte[] boundary) {
            int[] res = new int[0];
            if (b.remaining() < boundary.length) {
                return res;
            }

            int search_window_pos = 0;
            byte[] search_window = new byte[4 * 1024 + boundary.length];

            int first_fill = (b.remaining() < search_window.length) ? b.remaining() : search_window.length;
            b.get(search_window, 0, first_fill);
            int new_bytes = first_fill - boundary.length;

            do {
                // Search the search_window
                for (int j = 0; j < new_bytes; j++) {
                    for (int i = 0; i < boundary.length; i++) {
                        if (search_window[j + i] != boundary[i])
                            break;
                        if (i == boundary.length - 1) {
                            // Match found, add it to results
                            int[] new_res = new int[res.length + 1];
                            System.arraycopy(res, 0, new_res, 0, res.length);
                            new_res[res.length] = search_window_pos + j;
                            res = new_res;
                        }
                    }
                }
                search_window_pos += new_bytes;

                // Copy the end of the buffer to the start
                System.arraycopy(search_window, search_window.length - boundary.length, search_window, 0, boundary.length);

                // Refill search_window
                new_bytes = search_window.length - boundary.length;
                new_bytes = (b.remaining() < new_bytes) ? b.remaining() : new_bytes;
                b.get(search_window, boundary.length, new_bytes);
            } while (new_bytes > 0);
            return res;
        }

        @Override
        public CookieHandler getCookies() {
            return this.cookies;
        }

        @Override
        public final Map<String, String> getHeaders() {
            return this.headers;
        }

        @Override
        public final Map<String, String> getFiles() {
            return this.files;
        }
        
        public Socket getSocket() { return socket; }

        @Override
        public final InputStream getInputStream() {
            return this.inputStream;
        }

        @Override
        public final OutputStream getOutputStream() {
            return this.outputStream;
        }

        @Override
        public final Method getMethod() {
            return this.method;
        }

        @Override
        public final Map<String, String> getParms() {
            return this.parms;
        }

        @Override
        public String getQueryParameterString() {
            return this.queryParameterString;
        }

        private RandomAccessFile getTmpBucket() {
            try {
                TempFile tempFile = this.tempFileManager.createTempFile();
                return new RandomAccessFile(tempFile.getName(), "rw");
            } catch (Exception e) {
                throw new Error(e); // we won't recover, so throw an error
            }
        }

        @Override
        public final String getUri() {
            return this.uri;
        }

        @Override
        public void parseBody() throws IOException, ResponseException {
            final int REQUEST_BUFFER_LEN = 512;
            final int MEMORY_STORE_LIMIT = 1024;
            RandomAccessFile randomAccessFile = null;
            try {
                long size;
                if (this.headers.containsKey("content-length")) {
                    size = Integer.parseInt(this.headers.get("content-length"));
                } else if (this.splitbyte < this.rlen) {
                    size = this.rlen - this.splitbyte;
                } else {
                    size = 0;
                }

                ByteArrayOutputStream baos = null;
                DataOutput request_data_output = null;

                // Store the request in memory or a file, depending on size
                if (size < MEMORY_STORE_LIMIT) {
                    baos = new ByteArrayOutputStream();
                    request_data_output = new DataOutputStream(baos);
                } else {
                    randomAccessFile = getTmpBucket();
                    request_data_output = randomAccessFile;
                }

                // Read all the body and write it to request_data_output
                byte[] buf = new byte[REQUEST_BUFFER_LEN];
                while (this.rlen >= 0 && size > 0) {
                    this.rlen = this.inputStream.read(buf, 0, (int) Math.min(size, REQUEST_BUFFER_LEN));
                    size -= this.rlen;
                    if (this.rlen > 0) {
                        request_data_output.write(buf, 0, this.rlen);
                    }
                }

                java.nio.ByteBuffer fbuf = null;
                if (baos != null) {
                    fbuf = java.nio.ByteBuffer.wrap(baos.toByteArray(), 0, baos.size());
                } else {
                    fbuf = randomAccessFile.getChannel().map(FileChannel.MapMode.READ_ONLY, 0, randomAccessFile.length());
                    randomAccessFile.seek(0);
                }

                // If the method is POST, there may be parameters
                // in data section, too, read it:
                if (Method.POST.equals(this.method)) {
                    String contentType = "";
                    String contentTypeHeader = this.headers.get("content-type");

                    StringTokenizer st = null;
                    if (contentTypeHeader != null) {
                        st = new StringTokenizer(contentTypeHeader, ",; ");
                        if (st.hasMoreTokens()) {
                            contentType = st.nextToken();
                        }
                    }

                    if ("multipart/form-data".equalsIgnoreCase(contentType)) {
                        // Handle multipart/form-data
                        if (!st.hasMoreTokens()) {
                            throw new ResponseException(Status.BAD_REQUEST,
                                    "BAD REQUEST: Content type is multipart/form-data but boundary missing. Usage: GET /example/file.html");
                        }

                        String boundaryStartString = "boundary=";
                        int boundaryContentStart = contentTypeHeader.indexOf(boundaryStartString) + boundaryStartString.length();
                        String boundary = contentTypeHeader.substring(boundaryContentStart, contentTypeHeader.length());
                        if (boundary.startsWith("\"") && boundary.endsWith("\"")) {
                            boundary = boundary.substring(1, boundary.length() - 1);
                        }

                        decodeMultipartFormData(boundary, fbuf, this.parms, files);
                    } else {
                        byte[] postBytes = new byte[fbuf.remaining()];
                        if (NanoHTTPD_debug)
                          print("NanoHTTPD: Handling POST data (" + l(postBytes) + " bytes)");
                        fbuf.get(postBytes);
                        String postLine = new String(postBytes).trim();
                        // Handle application/x-www-form-urlencoded
                        if ("application/x-www-form-urlencoded".equalsIgnoreCase(contentType)) {
                            decodeParms(postLine, this.parms);
                        } else if (postLine.length() != 0) {
                            // Special case for raw POST data => create a
                            // special files entry "postData" with raw content
                            // data
                            files.put("postData", postLine);
                        }
                    }
                } else if (Method.PUT.equals(this.method)) {
                    files.put("content", saveTmpFile(fbuf, 0, fbuf.limit()));
                }
            } finally {
                safeClose(randomAccessFile);
            }
        }

        /**
         * Retrieves the content of a sent file and saves it to a temporary
         * file. The full path to the saved file is returned.
         */
        private String saveTmpFile(java.nio.ByteBuffer b, int offset, int len) {
            String path = "";
            if (len > 0) {
                FileOutputStream fileOutputStream = null;
                try {
                    TempFile tempFile = this.tempFileManager.createTempFile();
                    java.nio.ByteBuffer src = b.duplicate();
                    fileOutputStream = new FileOutputStream(tempFile.getName());
                    FileChannel dest = fileOutputStream.getChannel();
                    src.position(offset).limit(offset + len);
                    dest.write(src.slice());
                    path = tempFile.getName();
                } catch (Exception e) { // Catch exception if any
                    throw new Error(e); // we won't recover, so throw an error
                } finally {
                    safeClose(fileOutputStream);
                }
            }
            return path;
        }
        
        public String remoteIp() { return remoteIp; }
    } // end of HTTPSession

    /**
     * Handles one session, i.e. parses the HTTP request and returns the
     * response.
     */
    public interface IHTTPSession {
    
        void badClient(boolean b);
        void specialHandler(boolean b);

        void execute() throws IOException;

        CookieHandler getCookies();

        Map<String, String> getHeaders();
        
        Map<String, String> getFiles();

        Socket getSocket();
        InputStream getInputStream();
        OutputStream getOutputStream();

        Method getMethod();
        
        String getProtocolVersion();
        String getFullURI();
        
        List<String> getHeaderLines();

        Map<String, String> getParms();

        String getQueryParameterString();

        /**
         * @return the path part of the URL.
         */
        String getUri();

        /**
         * Adds the files in the request body to the files map.
         * 
         * @param files
         *            map to modify
         */
        void parseBody() throws IOException, ResponseException;
        
        String remoteIp();
    }

    /**
     * HTTP Request methods, with the ability to decode a <code>String</code>
     * back to its enum value.
     */
    public enum Method {
        GET,
        PUT,
        POST,
        DELETE,
        HEAD,
        OPTIONS,
        TRACE,
        CONNECT,
        PATCH;

        static Method lookup(String method) {
            for (Method m : Method.values()) {
                if (m.toString().equalsIgnoreCase(method)) {
                    return m;
                }
            }
            return null;
        }
    }

    /**
     * HTTP response. Return one of these from serve().
     */
    public static class Response implements Closeable {

        public String toString() {
          return "HttpResponse " + status + " " + mimeType;
        }

        /**
         * Output stream that will automatically send every write to the wrapped
         * OutputStream according to chunked transfer:
         * http://www.w3.org/Protocols/rfc2616/rfc2616-sec3.html#sec3.6.1
         */
        private static class ChunkedOutputStream extends FilterOutputStream {

            public ChunkedOutputStream(OutputStream out) {
                super(out);
            }

            @Override
            public void write(int b) throws IOException {
                byte[] data = {
                    (byte) b
                };
                write(data, 0, 1);
            }

            @Override
            public void write(byte[] b) throws IOException {
                write(b, 0, b.length);
            }

            @Override
            public void write(byte[] b, int off, int len) throws IOException {
                if (len == 0)
                    return;
                out.write(String.format("%x\r\n", len).getBytes());
                out.write(b, off, len);
                out.write("\r\n".getBytes());
            }

            public void finish() throws IOException {
                out.write("0\r\n\r\n".getBytes());
            }

        }

        /**
         * HTTP status code after processing, e.g. "200 OK", Status.OK
         */
        private IStatus status;

        /**
         * MIME type of content, e.g. "text/html"
         */
        private String mimeType;

        /**
         * Data of the response, may be null.
         */
        private InputStream data;

        private long contentLength;

        /**
         * Headers for the HTTP response. Use addHeader() to add lines.
         */
        //private final Map<String, String> header = new HashMap<String, String>();
        final Map<String, String> header = lithashmap("X-Powered-By", "JavaX");

        /**
         * The request method that spawned this response.
         */
        private Method requestMethod;

        /**
         * Use chunkedTransfer
         */
        private boolean chunkedTransfer = false;

        private boolean encodeAsGzip = false;

        private boolean keepAlive = false;

        /**
         * Creates a fixed length response if totalBytes>=0, otherwise chunked.
         */
        protected Response(IStatus status, String mimeType, InputStream data, long totalBytes) {
            this.status = status;
            this.mimeType = mimeType;
            if (data == null) {
                this.data = new ByteArrayInputStream(new byte[0]);
                this.contentLength = 0L;
            } else {
                this.data = data;
                this.contentLength = totalBytes;
            }
            this.chunkedTransfer = this.contentLength < 0;
            keepAlive = true;
        }

        @Override
        public void close() throws IOException {
            if (this.data != null) {
                this.data.close();
            }
        }

        /**
         * Adds given line to the header.
         */
        public void addHeader(String name, String value) {
            this.header.put(name, value);
        }

        public InputStream getData() {
            return this.data;
        }

        public String getHeader(String name) {
            for (String headerName : header.keySet()) {
                if (headerName.equalsIgnoreCase(name)) {
                    return header.get(headerName);
                }
            }
            return null;
        }

        public String getMimeType() {
            return this.mimeType;
        }

        public Method getRequestMethod() {
            return this.requestMethod;
        }

        public IStatus getStatus() {
            return this.status;
        }

        public void setGzipEncoding(boolean encodeAsGzip) {
            this.encodeAsGzip = encodeAsGzip;
        }

        public void setKeepAlive(boolean useKeepAlive) {
            this.keepAlive = useKeepAlive;
        }

        private boolean headerAlreadySent(Map<String, String> header, String name) {
            boolean alreadySent = false;
            for (String headerName : header.keySet()) {
                alreadySent |= headerName.equalsIgnoreCase(name);
            }
            return alreadySent;
        }

        /**
         * Sends given response to the socket.
         */
        protected void send(OutputStream outputStream) {
            String mime = this.mimeType;
            SimpleDateFormat gmtFrmt = new SimpleDateFormat("E, d MMM yyyy HH:mm:ss 'GMT'", Locale.US);
            gmtFrmt.setTimeZone(TimeZone.getTimeZone("GMT"));

            try {
                if (this.status == null) {
                    throw new Error("sendResponse(): Status can't be null.");
                }
                PrintWriter pw = new PrintWriter(new BufferedWriter(new OutputStreamWriter(outputStream, "UTF-8")), false);
                pw.print("HTTP/1.1 " + this.status.getDescription() + " \r\n");

                if (mime != null) {
                    pw.print("Content-Type: " + mime + "\r\n");
                }

                if (this.header == null || this.header.get("Date") == null) {
                    pw.print("Date: " + gmtFrmt.format(new Date()) + "\r\n");
                }

                if (this.header != null) {
                    for (String key : this.header.keySet()) {
                        String value = this.header.get(key);
                        pw.print(key + ": " + value + "\r\n");
                    }
                }

                if (!headerAlreadySent(header, "connection")) {
                    pw.print("Connection: " + (this.keepAlive ? "keep-alive" : "close") + "\r\n");
                }

                if (headerAlreadySent(this.header, "content-length")) {
                    encodeAsGzip = false;
                }

                if (encodeAsGzip) {
                    pw.print("Content-Encoding: gzip\r\n");
                    setChunkedTransfer(true);
                }

                long pending = this.data != null ? this.contentLength : 0;
                if (this.requestMethod != Method.HEAD && this.chunkedTransfer) {
                    pw.print("Transfer-Encoding: chunked\r\n");
                } else if (!encodeAsGzip) {
                    pending = sendContentLengthHeaderIfNotAlreadyPresent(pw, this.header, pending);
                }
                pw.print("\r\n");
                pw.flush();
                sendBodyWithCorrectTransferAndEncoding(outputStream, pending);
                outputStream.flush();
                safeClose(this.data);
            } catch (IOException ioe) {
                NanoHTTPD.LOG.log(Level.SEVERE, "Could not send response to the client", ioe);
            }
        }

        private void sendBodyWithCorrectTransferAndEncoding(OutputStream outputStream, long pending) throws IOException {
            if (this.requestMethod != Method.HEAD && this.chunkedTransfer) {
                ChunkedOutputStream chunkedOutputStream = new ChunkedOutputStream(outputStream);
                sendBodyWithCorrectEncoding(chunkedOutputStream, -1);
                chunkedOutputStream.finish();
            } else {
                sendBodyWithCorrectEncoding(outputStream, pending);
            }
        }

        private void sendBodyWithCorrectEncoding(OutputStream outputStream, long pending) throws IOException {
            if (encodeAsGzip) {
                GZIPOutputStream gzipOutputStream = new GZIPOutputStream(outputStream);
                sendBody(gzipOutputStream, -1);
                gzipOutputStream.finish();
            } else {
                sendBody(outputStream, pending);
            }
        }

        /**
         * Sends the body to the specified OutputStream. The pending parameter
         * limits the maximum amounts of bytes sent unless it is -1, in which
         * case everything is sent.
         * 
         * @param outputStream
         *            the OutputStream to send data to
         * @param pending
         *            -1 to send everything, otherwise sets a max limit to the
         *            number of bytes sent
         * @throws IOException
         *             if something goes wrong while sending the data.
         */
        private void sendBody(OutputStream outputStream, long pending) throws IOException {
            long BUFFER_SIZE = 16 * 1024;
            byte[] buff = new byte[(int) BUFFER_SIZE];
            boolean sendEverything = pending == -1;
            while (pending > 0 || sendEverything) {
                long bytesToRead = sendEverything ? BUFFER_SIZE : Math.min(pending, BUFFER_SIZE);
                int read = this.data.read(buff, 0, (int) bytesToRead);
                if (read <= 0) {
                    break;
                }
                outputStream.write(buff, 0, read);
                if (!sendEverything) {
                    pending -= read;
                }
            }
        }

        protected long sendContentLengthHeaderIfNotAlreadyPresent(PrintWriter pw, Map<String, String> header, long size) {
            for (String headerName : header.keySet()) {
                if (headerName.equalsIgnoreCase("content-length")) {
                    try {
                        return Long.parseLong(header.get(headerName));
                    } catch (NumberFormatException ex) {
                        return size;
                    }
                }
            }

            pw.print("Content-Length: " + size + "\r\n");
            return size;
        }

        public void setChunkedTransfer(boolean chunkedTransfer) {
            this.chunkedTransfer = chunkedTransfer;
        }

        public void setData(InputStream data) {
            this.data = data;
        }

        public void setMimeType(String mimeType) {
            this.mimeType = mimeType;
        }

        public void setRequestMethod(Method requestMethod) {
            this.requestMethod = requestMethod;
        }

        public void setStatus(IStatus status) {
            this.status = status;
        }
    }

    public static final class ResponseException extends Exception {

        private static final long serialVersionUID = 6569838532917408380L;

        private final Status status;

        public ResponseException(Status status, String message) {
            super(message);
            this.status = status;
        }

        public ResponseException(Status status, String message, Exception e) {
            super(message, e);
            this.status = status;
        }

        public Status getStatus() {
            return this.status;
        }
    }

    /**
     * The runnable that will be used for the main listening thread.
     */
    public class ServerRunnable implements Runnable {

        private final int timeout;

        private IOException bindException;

        private boolean hasBinded = false;

        private ServerRunnable(int timeout) {
            this.timeout = timeout;
        }

        @Override
        public void run() {
            try {
                myServerSocket.bind(hostname != null ? new InetSocketAddress(hostname, myPort) : new InetSocketAddress(myPort));
                hasBinded = true;
            } catch (IOException e) {
                print("Was trying to bind to port: " + myPort + (hostname == null ? "" : " on " + hostname));
                this.bindException = e;
                return;
            }
            do {
                try {
                    final Socket finalAccept = NanoHTTPD.this.myServerSocket.accept();
                    if (NanoHTTPD_debug) print("NanoHTTPD: New socket.");
                    if (this.timeout > 0) {
                        finalAccept.setSoTimeout(this.timeout);
                    }
                    final InputStream inputStream = wrapStuff("SocketInputStream", finalAccept.getInputStream(), finalAccept, NanoHTTPD.this.myServerSocket);
                    if (NanoHTTPD_debug) print("NanoHTTPD: Have input stream.");
                    NanoHTTPD.this.asyncRunner.exec(createClientHandler(finalAccept, inputStream));
                } catch (IOException e) {
                    NanoHTTPD.LOG.log(Level.FINE, "Communication with the client broken", e);
                }
            } while (!NanoHTTPD.this.myServerSocket.isClosed());
        }
    }

    /**
     * A temp file.
     * <p/>
     * <p>
     * Temp files are responsible for managing the actual temporary storage and
     * cleaning themselves up when no longer needed.
     * </p>
     */
    public interface TempFile {

        void delete() throws Exception;

        String getName();

        OutputStream open() throws Exception;
    }

    /**
     * Temp file manager.
     * <p/>
     * <p>
     * Temp file managers are created 1-to-1 with incoming requests, to create
     * and cleanup temporary files created as a result of handling the request.
     * </p>
     */
    public interface TempFileManager {

        void clear();

        TempFile createTempFile() throws Exception;
    }

    /**
     * Factory to create temp file managers.
     */
    public interface TempFileManagerFactory {

        TempFileManager create();
    }

    /**
     * Maximum time to wait on Socket.getInputStream().read() (in milliseconds)
     * This is required as the Keep-Alive HTTP connections would otherwise block
     * the socket reading thread forever (or as long the browser is open).
     */
    public static int SOCKET_READ_TIMEOUT =
      // 5000;
      24*3600*1000; // for WebSockets!

    /**
     * Common MIME type for dynamic content: plain text
     */
    public static final String MIME_PLAINTEXT = "text/plain; charset=utf-8";

    /**
     * Common MIME type for dynamic content: html
     */
    public static final String MIME_HTML = "text/html; charset=utf-8";

    /**
     * Pseudo-Parameter to use to store the actual query string in the
     * parameters map for later re-processing.
     */
    private static final String QUERY_STRING_PARAMETER = "NanoHttpd.QUERY_STRING";

    /**
     * logger to log to.
     */
    private static final Logger LOG = Logger.getLogger(NanoHTTPD.class.getName());

    /**
     * Creates an SSLSocketFactory for HTTPS. Pass a loaded KeyStore and an
     * array of loaded KeyManagers. These objects must properly
     * loaded/initialized by the caller.
     */
    public static SSLServerSocketFactory makeSSLSocketFactory(KeyStore loadedKeyStore, KeyManager[] keyManagers) throws IOException {
        SSLServerSocketFactory res = null;
        try {
            TrustManagerFactory trustManagerFactory = TrustManagerFactory.getInstance(TrustManagerFactory.getDefaultAlgorithm());
            trustManagerFactory.init(loadedKeyStore);
            SSLContext ctx = SSLContext.getInstance("TLS");
            ctx.init(keyManagers, trustManagerFactory.getTrustManagers(), null);
            res = ctx.getServerSocketFactory();
        } catch (Exception e) {
            throw new IOException(e.getMessage());
        }
        return res;
    }

    /**
     * Creates an SSLSocketFactory for HTTPS. Pass a loaded KeyStore and a
     * loaded KeyManagerFactory. These objects must properly loaded/initialized
     * by the caller.
     */
    public static SSLServerSocketFactory makeSSLSocketFactory(KeyStore loadedKeyStore, KeyManagerFactory loadedKeyFactory) throws IOException {
        SSLServerSocketFactory res = null;
        try {
            TrustManagerFactory trustManagerFactory = TrustManagerFactory.getInstance(TrustManagerFactory.getDefaultAlgorithm());
            trustManagerFactory.init(loadedKeyStore);
            SSLContext ctx = SSLContext.getInstance("TLS");
            ctx.init(loadedKeyFactory.getKeyManagers(), trustManagerFactory.getTrustManagers(), null);
            res = ctx.getServerSocketFactory();
        } catch (Exception e) {
            throw new IOException(e.getMessage());
        }
        return res;
    }

    /**
     * Creates an SSLSocketFactory for HTTPS. Pass a KeyStore resource with your
     * certificate and passphrase
     */
    public static SSLServerSocketFactory makeSSLSocketFactory(String keyAndTrustStoreClasspathPath, char[] passphrase) throws IOException {
        SSLServerSocketFactory res = null;
        try {
            KeyStore keystore = KeyStore.getInstance(KeyStore.getDefaultType());
            InputStream keystoreStream = NanoHTTPD.class.getResourceAsStream(keyAndTrustStoreClasspathPath);
            keystore.load(keystoreStream, passphrase);
            TrustManagerFactory trustManagerFactory = TrustManagerFactory.getInstance(TrustManagerFactory.getDefaultAlgorithm());
            trustManagerFactory.init(keystore);
            KeyManagerFactory keyManagerFactory = KeyManagerFactory.getInstance(KeyManagerFactory.getDefaultAlgorithm());
            keyManagerFactory.init(keystore, passphrase);
            SSLContext ctx = SSLContext.getInstance("TLS");
            ctx.init(keyManagerFactory.getKeyManagers(), trustManagerFactory.getTrustManagers(), null);
            res = ctx.getServerSocketFactory();
        } catch (Exception e) {
            throw new IOException(e.getMessage());
        }
        return res;
    }

    private static final void safeClose(Object closeable) {
        try {
            if (closeable != null) {
                if (closeable instanceof Closeable) {
                    ((Closeable) closeable).close();
                } else if (closeable instanceof Socket) {
                    ((Socket) closeable).close();
                } else if (closeable instanceof ServerSocket) {
                    ((ServerSocket) closeable).close();
                } else {
                    throw new IllegalArgumentException("Unknown object to close");
                }
            }
        } catch (IOException e) {
            NanoHTTPD.LOG.log(Level.SEVERE, "Could not close", e);
        }
    }

    private final String hostname;

    private final int myPort;

    private ServerSocket myServerSocket;

    private SSLServerSocketFactory sslServerSocketFactory;

    private Thread myThread;

    /**
     * Pluggable strategy for asynchronously executing requests.
     */
    protected AsyncRunner asyncRunner;

    /**
     * Pluggable strategy for creating and cleaning up temporary files.
     */
    private TempFileManagerFactory tempFileManagerFactory;

    /**
     * Constructs an HTTP server on given port.
     */
    public NanoHTTPD(int port) {
        this(null, port);
    }

    // -------------------------------------------------------------------------------
    // //
    //
    // Threading Strategy.
    //
    // -------------------------------------------------------------------------------
    // //

    /**
     * Constructs an HTTP server on given hostname and port.
     */
    public NanoHTTPD(String hostname, int port) {
        this.hostname = hostname;
        this.myPort = port;
        setTempFileManagerFactory(new DefaultTempFileManagerFactory());
        setAsyncRunner(new DefaultAsyncRunner());
    }

    /**
     * Forcibly closes all connections that are open.
     */
    public synchronized void closeAllConnections() {
        stop();
    }

    /**
     * create a instance of the client handler, subclasses can return a subclass
     * of the ClientHandler.
     * 
     * @param finalAccept
     *            the socket the cleint is connected to
     * @param inputStream
     *            the input stream
     * @return the client handler
     */
    protected ClientHandler createClientHandler(final Socket finalAccept, final InputStream inputStream) {
        return new ClientHandler(inputStream, finalAccept);
    }

    /**
     * Instantiate the server runnable, can be overwritten by subclasses to
     * provide a subclass of the ServerRunnable.
     * 
     * @param timeout
     *            the socet timeout to use.
     * @return the server runnable.
     */
    protected ServerRunnable createServerRunnable(final int timeout) {
        return new ServerRunnable(timeout);
    }

    /**
     * Decode parameters from a URL, handing the case where a single parameter
     * name might have been supplied several times, by return lists of values.
     * In general these lists will contain a single element.
     * 
     * @param parms
     *            original <b>NanoHTTPD</b> parameters values, as passed to the
     *            <code>serve()</code> method.
     * @return a map of <code>String</code> (parameter name) to
     *         <code>List&lt;String&gt;</code> (a list of the values supplied).
     */
    protected Map<String, List<String>> decodeParameters(Map<String, String> parms) {
        return this.decodeParameters(parms.get(NanoHTTPD.QUERY_STRING_PARAMETER));
    }

    // -------------------------------------------------------------------------------
    // //

    /**
     * Decode parameters from a URL, handing the case where a single parameter
     * name might have been supplied several times, by return lists of values.
     * In general these lists will contain a single element.
     * 
     * @param queryString
     *            a query string pulled from the URL.
     * @return a map of <code>String</code> (parameter name) to
     *         <code>List&lt;String&gt;</code> (a list of the values supplied).
     */
    protected Map<String, List<String>> decodeParameters(String queryString) {
        Map<String, List<String>> parms = new HashMap<String, List<String>>();
        if (queryString != null) {
            StringTokenizer st = new StringTokenizer(queryString, "&");
            while (st.hasMoreTokens()) {
                String e = st.nextToken();
                int sep = e.indexOf('=');
                String propertyName = sep >= 0 ? decodePercent(e.substring(0, sep)).trim() : decodePercent(e).trim();
                if (!parms.containsKey(propertyName)) {
                    parms.put(propertyName, new ArrayList<String>());
                }
                String propertyValue = sep >= 0 ? decodePercent(e.substring(sep + 1)) : null;
                // XXX Stefan - allow raw parameters - took the if out:
                /* if (propertyValue != null) */ {
                    parms.get(propertyName).add(propertyValue);
                }
            }
        }
        return parms;
    }

    /**
     * Decode percent encoded <code>String</code> values.
     * 
     * @param str
     *            the percent encoded <code>String</code>
     * @return expanded form of the input, for example "foo%20bar" becomes
     *         "foo bar"
     */
    protected String decodePercent(String str) {
        String decoded = null;
        try {
            decoded = URLDecoder.decode(str, "UTF8");
        } catch (UnsupportedEncodingException ignored) {
            NanoHTTPD.LOG.log(Level.WARNING, "Encoding not supported, ignored", ignored);
        }
        return decoded;
    }

    /**
     * @return true if the gzip compression should be used if the client
     *         accespts it. Default this option is on for text content and off
     *         for everything else.
     */
    protected boolean useGzipWhenAccepted(Response r) {
        return r.getMimeType() != null && r.getMimeType().toLowerCase().contains("text/");
    }

    public final int getListeningPort() {
        return this.myServerSocket == null ? -1 : this.myServerSocket.getLocalPort();
    }

    public final boolean isAlive() {
        return wasStarted() && !this.myServerSocket.isClosed() && this.myThread.isAlive();
    }

    public void join() throws InterruptedException {
      myThread.join();
    }

    /**
     * Call before start() to serve over HTTPS instead of HTTP
     */
    public void makeSecure(SSLServerSocketFactory sslServerSocketFactory) {
        this.sslServerSocketFactory = sslServerSocketFactory;
    }

    /**
     * Create a response with unknown length (using HTTP 1.1 chunking).
     */
    public static Response newChunkedResponse(IStatus status, String mimeType, InputStream data) {
        return new Response(status, mimeType, data, -1);
    }

    /**
     * Create a response with known length.
     */
    public static Response newFixedLengthResponse(IStatus status, String mimeType, InputStream data, long totalBytes) {
        return new Response(status, mimeType, data, totalBytes);
    }

    /**
     * Create a text response with known length.
     */
    public static Response newFixedLengthResponse(IStatus status, String mimeType, String txt) {
        if (txt == null) {
            return newFixedLengthResponse(status, mimeType, new ByteArrayInputStream(new byte[0]), 0);
        } else {
            byte[] bytes;
            try {
                bytes = txt.getBytes("UTF-8");
            } catch (UnsupportedEncodingException e) {
                NanoHTTPD.LOG.log(Level.SEVERE, "encoding problem, responding nothing", e);
                bytes = new byte[0];
            }
            return newFixedLengthResponse(status, mimeType, new ByteArrayInputStream(bytes), bytes.length);
        }
    }

    /**
     * Create a text response with known length.
     */
    public static Response newFixedLengthResponse(String msg) {
        return newFixedLengthResponse(Status.OK, NanoHTTPD.MIME_HTML, msg);
    }

    /**
     * Override this to customize the server.
     * <p/>
     * <p/>
     * (By default, this returns a 404 "Not Found" plain text error response.)
     * 
     * @param session
     *            The HTTP session
     * @return HTTP response, see class Response for details
     */
    public Response serve(IHTTPSession session) {
        if (specialHandling(session)) {
          session.specialHandler(true);
          return null;
        }
        
        return serve_2(session);
    }
        
    public Response serve_2(IHTTPSession session) {      
        currentSession.set(session);
        Method method = session.getMethod();
        if (Method.PUT.equals(method) || Method.POST.equals(method)) {
            try {
                session.parseBody();
            } catch (IOException ioe) {
                return newFixedLengthResponse(Status.INTERNAL_ERROR, NanoHTTPD.MIME_PLAINTEXT, "SERVER INTERNAL ERROR: IOException: " + ioe.getMessage());
            } catch (ResponseException re) {
                return newFixedLengthResponse(re.getStatus(), NanoHTTPD.MIME_PLAINTEXT, re.getMessage());
            }
        }

        Map<String, String> parms = session.getParms();
        if (!noQueryStringParameter)
          parms.put(NanoHTTPD.QUERY_STRING_PARAMETER, session.getQueryParameterString());
        return serve(session.getUri(), method, session.getHeaders(), parms, session.getFiles());
    }

    /**
     * Override this to customize the server.
     * <p/>
     * <p/>
     * (By default, this returns a 404 "Not Found" plain text error response.)
     * 
     * @param uri
     *            Percent-decoded URI without parameters, for example
     *            "/index.cgi"
     * @param method
     *            "GET", "POST" etc.
     * @param parms
     *            Parsed, percent decoded parameters from URI and, in case of
     *            POST, data.
     * @param headers
     *            Header entries, percent decoded
     * @return HTTP response, see class Response for details
     */
    @Deprecated
    public Response serve(String uri, Method method, Map<String, String> headers, Map<String, String> parms, Map<String, String> files) {
        return newFixedLengthResponse(Status.NOT_FOUND, NanoHTTPD.MIME_PLAINTEXT, "Not Found");
    }

    /**
     * Pluggable strategy for asynchronously executing requests.
     * 
     * @param asyncRunner
     *            new strategy for handling threads.
     */
    public void setAsyncRunner(AsyncRunner asyncRunner) {
        this.asyncRunner = asyncRunner;
    }

    /**
     * Pluggable strategy for creating and cleaning up temporary files.
     * 
     * @param tempFileManagerFactory
     *            new strategy for handling temp files.
     */
    public void setTempFileManagerFactory(TempFileManagerFactory tempFileManagerFactory) {
        this.tempFileManagerFactory = tempFileManagerFactory;
    }

    /**
     * Start the server.
     * 
     * @throws IOException
     *             if the socket is in use.
     */
    public void start() throws IOException {
        start(NanoHTTPD.SOCKET_READ_TIMEOUT);
    }

    /**
     * Start the server.
     * 
     * @param timeout
     *            timeout to use for socket connections.
     * @throws IOException
     *             if the socket is in use.
     */
    public void start(final int timeout) throws IOException {
        boolean ssl = this.sslServerSocketFactory != null;
        if (ssl) {
            SSLServerSocket ss = (SSLServerSocket) this.sslServerSocketFactory.createServerSocket();
            ss.setNeedClientAuth(false);
            this.myServerSocket = ss;
        } else {
            this.myServerSocket = new ServerSocket();
        }
        this.myServerSocket.setReuseAddress(true);

        ServerRunnable serverRunnable = createServerRunnable(timeout);
        this.myThread = new Thread(serverRunnable);
        //this.myThread.setDaemon(true);
        this.myThread.setName("NanoHttpd Main Listener");
        this.myThread.start();
        while (!serverRunnable.hasBinded && serverRunnable.bindException == null) {
            try {
                Thread.sleep(10L);
            } catch (Throwable e) {
                // on android this may not be allowed, that's why we
                // catch throwable the wait should be very short because we are
                // just waiting for the bind of the socket
            }
        }
        if (serverRunnable.bindException != null) {
            throw serverRunnable.bindException;
        }
        
      System.out.println("HTTP" + (ssl ? "S" : "") + " server started (listening on port " + getListeningPort() + "!)");
      printMyIPs();
    }

    /**
     * Stop the server.
     */
    public void stop() {
        try {
            safeClose(this.myServerSocket);
            this.asyncRunner.closeAll();
            if (this.myThread != null) {
                this.myThread.join();
            }
        } catch (Exception e) {
            NanoHTTPD.LOG.log(Level.SEVERE, "Could not stop all connections", e);
        }
    }

    public final boolean wasStarted() {
        return this.myServerSocket != null && this.myThread != null;
    }

  
static void printMyIPs() {
String ip;
  try {
      Enumeration<NetworkInterface> interfaces = NetworkInterface.getNetworkInterfaces();
      while (interfaces.hasMoreElements()) {
          NetworkInterface iface = interfaces.nextElement();
          // filters out 127.0.0.1 and inactive interfaces
          if (iface.isLoopback() || !iface.isUp())
              continue;

          Enumeration<InetAddress> addresses = iface.getInetAddresses();
          while(addresses.hasMoreElements()) {
              InetAddress addr = addresses.nextElement();
              ip = addr.getHostAddress();
if (ip.startsWith("127.")) continue;
boolean local = addr.isSiteLocalAddress() || ip.startsWith("fe");
              System.out.println(iface.getDisplayName() + " " + ip + " " + (local ? "(private address)" : "(public address)"));
          }
      }
  } catch (Throwable e) {
      e.printStackTrace();
  }
}
static interface IStatus {
    String getDescription();
    int getRequestStatus();
  }
  
  /**
   * Some HTTP response status codes
   */
  static enum Status implements IStatus {
      SWITCH_PROTOCOL(101, "Switching Protocols"),
      OK(200, "OK"),
      CREATED(201, "Created"),
      ACCEPTED(202, "Accepted"),
      NO_CONTENT(204, "No Content"),
      PARTIAL_CONTENT(206, "Partial Content"),
      REDIRECT(301, "Moved Permanently"),
      NOT_MODIFIED(304, "Not Modified"),
      BAD_REQUEST(400, "Bad Request"),
      UNAUTHORIZED(401, "Unauthorized"),
      FORBIDDEN(403, "Forbidden"),
      NOT_FOUND(404, "Not Found"),
      METHOD_NOT_ALLOWED(405, "Method Not Allowed"),
      REQUEST_TIMEOUT(408, "Request Timeout"),
      RANGE_NOT_SATISFIABLE(416, "Requested Range Not Satisfiable"),
      INTERNAL_ERROR(500, "Internal Server Error"),
      UNSUPPORTED_HTTP_VERSION(505, "HTTP Version Not Supported");
  
      private final int requestStatus;
  
      private final String description;
  
      Status(int requestStatus, String description) {
          this.requestStatus = requestStatus;
          this.description = description;
      }
  
      @Override
      public String getDescription() {
          return "" + this.requestStatus + " " + this.description;
      }
  
      @Override
      public int getRequestStatus() {
          return this.requestStatus;
      }
  }
  
  int getPort() { return myPort; }
  
  public void close() { stop(); }
  
  // plug in proxies etc here
  // return true if handled
  transient  IF1<IHTTPSession, Boolean> specialHandling;
boolean specialHandling(IHTTPSession session) { return specialHandling != null ? specialHandling.get(session) : specialHandling_base(session); }
final boolean specialHandling_fallback(IF1<IHTTPSession, Boolean> _f, IHTTPSession session) { return _f != null ? _f.get(session) : specialHandling_base(session); }
boolean specialHandling_base(IHTTPSession session) {
    return false;
  }
} // end of NanoHTTPD

static abstract class DialogIO implements AutoCloseable {
  String line;
  boolean eos, loud, noClose;
  Lock lock = lock();
  
  abstract String readLineImpl();
  abstract boolean isStillConnected();
  abstract void sendLine(String line);
  abstract boolean isLocalConnection();
  abstract Socket getSocket();

  int getPort() { Socket s = getSocket(); return s == null ? 0 : s.getPort(); }
  
  boolean helloRead = false;
  int shortenOutputTo = 500;
  
  String readLineNoBlock() {
    String l = line;
    line = null;
    return l;
  }
  
  boolean waitForLine() { try {
    ping();
    if (line != null) return true;
    //print("Readline");
    line = readLineImpl();
    //print("Readline done: " + line);
    if (line == null) eos = true;
    return line != null;
  } catch (Exception __e) { throw rethrow(__e); } }
  
  String readLine() {
    waitForLine();
    helloRead = true;
    return readLineNoBlock();
  }
  
  String ask(String s, Object... args) {
    if (loud) return askLoudly(s, args);
    if (!helloRead) readLine();
    if (args.length != 0) s = format3(s, args);
    sendLine(s);
    return readLine();
  }
  
  String askLoudly(String s, Object... args) {
    if (!helloRead) readLine();
    if (args.length != 0) s = format3(s, args);
    print("> " + shorten(s, shortenOutputTo));
    sendLine(s);
    String answer = readLine();
    print("< " + shorten(answer, shortenOutputTo));
    return answer;
  }
  
  void pushback(String l) {
    if (line != null)
      throw fail();
    line = l;
    helloRead = false;
  }
}

static abstract class DialogHandler implements IDialogHandler {}

interface IDialogHandler {
  void run(DialogIO io);
}
static class HostAndPort implements IFieldsToList{
  String host;
  int port;
  HostAndPort() {}
  HostAndPort(String host, int port) {
  this.port = port;
  this.host = host;}

public boolean equals(Object o) {
if (!(o instanceof HostAndPort)) return false;
    HostAndPort __1 =  (HostAndPort) o;
    return eq(host, __1.host) && port == __1.port;
}

  public int hashCode() {
    int h = -1463689200;
    h = boostHashCombine(h, _hashCode(host));
    h = boostHashCombine(h, _hashCode(port));
    return h;
  }
  public Object[] _fieldsToList() { return new Object[] {host, port}; }

  HostAndPort(String s) {
    int i = indexOf(s, ':');
    if (i < 0)
      host = s;
    else {
      host = takeFirst(i, s);
      port = parseInt(dropFirst(i+1, s));
    }
  }
  
  public String toString() {
    //ret host + (port == 0 ? "" : ":" + port);
    return host + ":" + port;
  }
}
// records its full size (total value count) in a field now
static class MultiMap<A,B> implements IMultiMap<A, B> {
  Map<A, List<B>> data = new HashMap<A, List<B>>();
  int fullSize;
  
  MultiMap() {}
  MultiMap(boolean useTreeMap) { if (useTreeMap) data = new TreeMap(); }
  MultiMap(MultiMap<A, B> map) { putAll(map); }
  MultiMap(Map<A, List<B>> data) {
  this.data = data;}

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

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

  void addAll(A key, Collection<B> values) { putAll(key, values); }
  
  void addAllIfNotThere(A key, Collection<B> values) { synchronized(data) {
    for (B value : values)
      setPut(key, value);
  }}
  
  void setPut(A key, B value) { synchronized(data) {
    if (!containsPair(key, value))
      put(key, value);
  }}
  
  boolean containsPair(A key, B value) { synchronized(data) {
    return get(key).contains(value);
  }}
  
  void putAll(Collection<A> keys, B value) { synchronized(data) {
    for (A key : unnullForIteration(keys))
      put(key, value);
  }}

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

  void putAll(Iterable<Pair<A, B>> pairs) { synchronized(data) {
    for (Pair<A, B> p : unnullForIteration(pairs))
      put(p.a, p.b);
  }}
  
  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;
  }}
  
  List<B> getOpt(A key) { synchronized(data) {
    return data.get(key);
  }}

  List<B> getAndClear(A key) { synchronized(data) {
    List<B> l = cloneList(data.get(key));
    remove(key);
    return l;
  }}
  
  // returns actual mutable live list
  // creates the list if not there
  List<B> getActual(A key) { synchronized(data) {
    List<B> list = data.get(key);
    if (list == null)
      data.put(key, list = _makeEmptyList());
    return list;
  }}
 
  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();
  }}

  void remove(A key) { synchronized(data) {
    fullSize -= l(this.getOpt(key));
    data.remove(key);
  }}
  
  final void remove(Pair<A, B> p){ removePair(p); }
void removePair(Pair<A, B> p) {
    if (p != null) remove(p.a, p.b);
  }

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

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

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

  B getFirst(A key) { synchronized(data) {
    List<B> list = get(key);
    return list.isEmpty() ? null : list.get(0);
  }}
  
  void addAll(MultiMap<A, B> map) { putAll(map); }
  
  void putAll(MultiMap<A, B> map) { synchronized(data) {
    for (A key : map.keySet())
      putAll(key, map.get(key));
  }}
  
  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;
  }}
  
  // expensive operation
  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;
  }}
  
  Map<A, List<B>> asMap() { synchronized(data) {
    return cloneMap(data);
  }}
  
  public boolean isEmpty() { synchronized(data) { return data.isEmpty(); }}
  
  // override in subclasses
  List<B> _makeEmptyList() {
    return new ArrayList();
  }
  
  // returns live lists
  Collection<List<B>> allLists() {
    synchronized(data) {
      return new ArrayList(data.values());
    }
  }
  Collection<List<B>> values() { return allLists(); }
  
  List<B> allValues() {
    return concatLists(data.values());
  }
  
  Object mutex() { return data; }
  
  public String toString() { return "mm" + str(data); }
  
  Map<A, List<B>> innerMap() { return data; }
}
// Note: This does have the values problem (complicated values can cause memory leaks)
static class BetterThreadLocal<A> {
  Map<Thread, A> map = newWeakHashMap();
  
  BetterThreadLocal() {}
  BetterThreadLocal(A value) { set(value); }
  
  boolean isSet() { return map.containsKey(currentThread()); }
  
  A get() {
    if (map.containsKey(currentThread()))
      return map.get(currentThread());
    A value = initialValue();
    set(value);
    return value;
  }
  
  A get(Thread thread) {
    return thread == null ? null : map.get(thread);
  }
  
  void set(A a) {
    map.put(currentThread(), a);
  }
  
  public A initialValue() { return null; }
}
static class Lowest<A> implements IBest<A> {
  A best;
  double score;
  transient Object onChange;
  
  synchronized boolean isNewBest(double score) {
    return best == null || score < this.score;
  }
  
  synchronized double bestScore() {
    return best == null ? Double.NaN : score;
  }
  
  double score() { return bestScore(); }
  
  synchronized float floatScore() {
    return best == null ? Float.NaN : (float) score;
  }
  
  synchronized 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 void clear() { best = null; score = 0; }
  
  synchronized A get() { return best; }
  synchronized boolean has() { return best != null; }
  synchronized Pair<A, Double> pair() { return best == null ? null : new Pair(best, bestScore()); }
  
  public String toString() {
    return "Score " + formatDouble_significant2(score, 4) + ": " + best;
  }
}
static interface IResourceLoader {
  String loadSnippet(String snippetID);
  String getTranspiled(String snippetID); // with libs
  int getSnippetType(String snippetID);
  String getSnippetTitle(String snippetID);
  File loadLibrary(String snippetID);
  
  //ifndef NoJavaXJar
  default File pathToJavaXJar() { return pathToJavaxJar_noResourceLoader(); }
  //endifndef

  // may return null, then caller compiles themselves
  default File getSnippetJar(String snippetID, String transpiledSrc) { return null; }
}
/*
 * @(#)WeakHashMap.java 1.5 98/09/30
 *
 * Copyright 1998 by Sun Microsystems, Inc.,
 * 901 San Antonio Road, Palo Alto, California, 94303, U.S.A.
 * All rights reserved.
 *
 * This software is the confidential and proprietary information
 * of Sun Microsystems, Inc. ("Confidential Information").  You
 * shall not disclose such Confidential Information and shall use
 * it only in accordance with the terms of the license agreement
 * you entered into with Sun.
 */
 
// From https://github.com/mernst/plume-lib/blob/df0bfafc3c16848d88f4ea0ef3c8bf3367ae085e/java/src/plume/WeakHasherMap.java

static final class WeakHasherMap<K,V> extends AbstractMap<K,V> implements Map<K,V> {

    private Hasher hasher = null;
    /*@Pure*/
    private boolean keyEquals(Object k1, Object k2) {
  return (hasher==null ? k1.equals(k2)
           : hasher.equals(k1, k2));
    }
    /*@Pure*/
    private int keyHashCode(Object k1) {
  return (hasher==null ? k1.hashCode()
           : hasher.hashCode(k1));
    }

    // The WeakKey class can't be static because it depends on the hasher.
    // That in turn means that its methods can't be static.
    // However, I need to be able to call the methods such as create() that
    // were static in the original version of this code.
    // This finesses that.

    private /*@Nullable*/ WeakKey WeakKeyCreate(K k) {
  if (k == null) return null;
  else return new WeakKey(k);
    }
    private /*@Nullable*/ WeakKey WeakKeyCreate(K k, ReferenceQueue<? super K> q) {
  if (k == null) return null;
  else return new WeakKey(k, q);
    }

    // Cannot be a static class: uses keyHashCode() and keyEquals()
    private final class WeakKey extends WeakReference<K> {
  private int hash; /* Hashcode of key, stored here since the key
           may be tossed by the GC */

  private WeakKey(K k) {
      super(k);
      hash = keyHashCode(k);
  }

  private /*@Nullable*/ WeakKey create(K k) {
      if (k == null) return null;
      else return new WeakKey(k);
  }

  private WeakKey(K k, ReferenceQueue<? super K> q) {
      super(k, q);
      hash = keyHashCode(k);
  }

  private /*@Nullable*/ WeakKey create(K k, ReferenceQueue<? super K> q) {
      if (k == null) return null;
      else return new WeakKey(k, q);
  }

        /* A WeakKey is equal to another WeakKey iff they both refer to objects
     that are, in turn, equal according to their own equals methods */
  /*@Pure*/
  @Override
  public boolean equals(/*@Nullable*/ Object o) {
            if (o == null) return false; // never happens
      if (this == o) return true;
            // This test is illegal because WeakKey is a generic type,
            // so use the getClass hack below instead.
      // if (!(o instanceof WeakKey)) return false;
            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);
  }

  /*@Pure*/
  @Override
  public int hashCode() {
      return hash;
  }

    }


    /* Hash table mapping WeakKeys to values */
    private HashMap<WeakKey,V> hash;

    /* Reference queue for cleared WeakKeys */
    private ReferenceQueue<? super K> queue = new ReferenceQueue<K>();


    /* Remove all invalidated entries from the map, that is, remove all entries
       whose keys have been discarded.  This method should be invoked once by
       each public mutator in this class.  We don't invoke this method in
       public accessors because that can lead to surprising
       ConcurrentModificationExceptions. */
    @SuppressWarnings("unchecked")
    private void processQueue() {
  WeakKey wk;
  while ((wk = (WeakKey)queue.poll()) != null) { // unchecked cast
      hash.remove(wk);
  }
    }


    /* -- Constructors -- */

    /**
     * Constructs a new, empty <code>WeakHashMap</code> with the given
     * initial capacity and the given load factor.
     *
     * @param  initialCapacity  the initial capacity of the
     *                          <code>WeakHashMap</code>
     *
     * @param  loadFactor       the load factor of the <code>WeakHashMap</code>
     *
     * @throws IllegalArgumentException  If the initial capacity is less than
     *                                   zero, or if the load factor is
     *                                   nonpositive
     */
    public WeakHasherMap(int initialCapacity, float loadFactor) {
  hash = new HashMap<WeakKey,V>(initialCapacity, loadFactor);
    }

    /**
     * Constructs a new, empty <code>WeakHashMap</code> with the given
     * initial capacity and the default load factor, which is
     * <code>0.75</code>.
     *
     * @param  initialCapacity  the initial capacity of the
     *                          <code>WeakHashMap</code>
     *
     * @throws IllegalArgumentException  If the initial capacity is less than
     *                                   zero
     */
    public WeakHasherMap(int initialCapacity) {
  hash = new HashMap<WeakKey,V>(initialCapacity);
    }

    /**
     * Constructs a new, empty <code>WeakHashMap</code> with the default
     * capacity and the default load factor, which is <code>0.75</code>.
     */
    public WeakHasherMap() {
  hash = new HashMap<WeakKey,V>();
    }

    /**
     * Constructs a new, empty <code>WeakHashMap</code> with the default
     * capacity and the default load factor, which is <code>0.75</code>.
     * The <code>WeakHashMap</code> uses the specified hasher for hashing
     * keys and comparing them for equality.
     * @param h the Hasher to use when hashing values for this map
     */
    public WeakHasherMap(Hasher h) {
  hash = new HashMap<WeakKey,V>();
  hasher = h;
    }


    /* -- Simple queries -- */

    /**
     * Returns the number of key-value mappings in this map.
     * <strong>Note:</strong> <em>In contrast to most implementations of the
     * <code>Map</code> interface, the time required by this operation is
     * linear in the size of the map.</em>
     */
    /*@Pure*/
    @Override
    public int size() {
  return entrySet().size();
    }

    /**
     * Returns <code>true</code> if this map contains no key-value mappings.
     */
    /*@Pure*/
    @Override
    public boolean isEmpty() {
  return entrySet().isEmpty();
    }

    /**
     * Returns <code>true</code> if this map contains a mapping for the
     * specified key.
     *
     * @param   key   the key whose presence in this map is to be tested
     */
    /*@Pure*/
    @Override
    public boolean containsKey(Object key) {
        @SuppressWarnings("unchecked")
        K kkey = (K) key;
  return hash.containsKey(WeakKeyCreate(kkey));
    }


    /* -- Lookup and modification operations -- */

    /**
     * Returns the value to which this map maps the specified <code>key</code>.
     * If this map does not contain a value for this key, then return
     * <code>null</code>.
     *
     * @param  key  the key whose associated value, if any, is to be returned
     */
    /*@Pure*/
    @Override
    public /*@Nullable*/ V get(Object key) {  // type of argument is Object, not K
        @SuppressWarnings("unchecked")
        K kkey = (K) key;
  return hash.get(WeakKeyCreate(kkey));
    }

    /**
     * Updates this map so that the given <code>key</code> maps to the given
     * <code>value</code>.  If the map previously contained a mapping for
     * <code>key</code> then that mapping is replaced and the previous value is
     * returned.
     *
     * @param  key    the key that is to be mapped to the given
     *                <code>value</code>
     * @param  value  the value to which the given <code>key</code> is to be
     *                mapped
     *
     * @return  the previous value to which this key was mapped, or
     *          <code>null</code> if if there was no mapping for the key
     */
    @Override
    public V put(K key, V value) {
  processQueue();
  return hash.put(WeakKeyCreate(key, queue), value);
    }

    /**
     * Removes the mapping for the given <code>key</code> from this map, if
     * present.
     *
     * @param  key  the key whose mapping is to be removed
     *
     * @return  the value to which this key was mapped, or <code>null</code> if
     *          there was no mapping for the key
     */
    @Override
    public V remove(Object key) { // type of argument is Object, not K
  processQueue();
        @SuppressWarnings("unchecked")
        K kkey = (K) key;
  return hash.remove(WeakKeyCreate(kkey));
    }

    /**
     * Removes all mappings from this map.
     */
    @Override
    public void clear() {
  processQueue();
  hash.clear();
    }


    /* -- Views -- */


    /* Internal class for entries */
    // This can't be static, again because of dependence on hasher.
    @SuppressWarnings("TypeParameterShadowing")
    private final class Entry<K,V> implements Map.Entry<K,V> {
  private Map.Entry<WeakKey,V> ent;
  private K key;  /* Strong reference to key, so that the GC
           will leave it alone as long as this Entry
           exists */

  Entry(Map.Entry<WeakKey,V> ent, K key) {
      this.ent = ent;
      this.key = key;
  }

  /*@Pure*/
  @Override
  public K getKey() {
      return key;
  }

  /*@Pure*/
  @Override
  public V getValue() {
      return ent.getValue();
  }

  @Override
  public V setValue(V value) {
      return ent.setValue(value);
  }

        /*@Pure*/
        private boolean keyvalEquals(K o1, K o2) {
      return (o1 == null) ? (o2 == null) : keyEquals(o1, o2);
  }

        /*@Pure*/
        private boolean valEquals(V o1, V o2) {
      return (o1 == null) ? (o2 == null) : o1.equals(o2);
  }

        /*@Pure*/
        @SuppressWarnings("NonOverridingEquals")
        public boolean equals(Map.Entry<K,V> e /* Object o*/) {
            // if (! (o instanceof Map.Entry)) return false;
            // Map.Entry<K,V> e = (Map.Entry<K,V>)o;
      return (keyvalEquals(key, e.getKey())
        && valEquals(getValue(), e.getValue()));
  }

  /*@Pure*/
  @Override
  public int hashCode() {
      V v;
      return (((key == null) ? 0 : keyHashCode(key))
        ^ (((v = getValue()) == null) ? 0 : v.hashCode()));
  }

    }


    /* Internal class for entry sets */
    private final class EntrySet extends AbstractSet<Map.Entry<K,V>> {
  Set<Map.Entry<WeakKey,V>> hashEntrySet = hash.entrySet();

  @Override
  public Iterator<Map.Entry<K,V>> iterator() {

      return new Iterator<Map.Entry<K,V>>() {
    Iterator<Map.Entry<WeakKey,V>> hashIterator = hashEntrySet.iterator();
    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)) {
          /* Weak key has been cleared by GC */
          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();
    }

      };
  }

  /*@Pure*/
  @Override
  public boolean isEmpty() {
      return !(iterator().hasNext());
  }

  /*@Pure*/
  @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; // unchecked cast
      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;
  }

  /*@Pure*/
  @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;
  }

    }


    private /*@Nullable*/ Set<Map.Entry<K,V>> entrySet = null;

    /**
     * Returns a <code>Set</code> view of the mappings in this map.
     */
    /*@SideEffectFree*/
    @Override
    public Set<Map.Entry<K,V>> entrySet() {
  if (entrySet == null) entrySet = new EntrySet();
  return entrySet;
    }

    // find matching key
    K findKey(Object key) {
      processQueue();
      K kkey = (K) key;
      // TODO: use replacement for HashMap to avoid reflection
      WeakKey wkey = WeakKeyCreate(kkey);
      WeakKey found = hashMap_findKey(hash, wkey);
      return found == null ? null : found.get();
    }
}
// just a marker interface for non-persistable classes
interface TransientObject {}
static class proxy_InvocationHandler implements InvocationHandler {
  Object target;
  
  proxy_InvocationHandler() {}
  proxy_InvocationHandler(Object target) {
  this.target = target;}
  
  public Object invoke(Object proxy, Method method, Object[] args) {
    return call(target, method.getName(), unnull(args));
  }
}
static 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; }
 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; }
 B b;

  Pair() {}
  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 interface IResourceHolder {
  <A extends AutoCloseable> A add(A a);
  Collection<AutoCloseable> takeAll();
}
static interface Swingable {
  JComponent visualize();
}
static class HandleProxyRequest {
  HostAndPort hap;
  boolean rewriteHost, rewritePort;
  NanoHTTPD.IHTTPSession session;
  IVF1<StandaloneHttpProxy.Request> customizeRequest;
  
  StandaloneHttpProxy proxy = new StandaloneHttpProxy();
  
  public void run() { try { try {
    String headers = windowsLineBreaks(lines(concatLists(
      ll(session.getMethod() + " " + session.getFullURI() + " " + session.getProtocolVersion()),
      withoutStartingWithIC("Host:", session.getHeaderLines())
    )));
    
    String domain = dropPortFromHost(mapGet(session.getHeaders(), "host"));
    
    proxy.rewriteHostHeader = rewritePort;
    proxy.forwardServerAndPort = req -> hap;
    proxy.takeOverIncomingSocket(domain, session.getSocket(),
      session.getInputStream(),
      session.getOutputStream(),
      toUtf8(printQuoted("HEADERS: ", headers)),
      customizeRequest);
  } catch (Exception __e) { throw rethrow(__e); } } catch (Exception __e) { throw rethrow(__e); } }
}
static class BetterLabel extends JLabel {
  boolean autoToolTip = true;
  
  BetterLabel() {
    // Listeners given out to componentPopupMenu must not directly
    // reference the outer object (-> weak map problem).
    final WeakReference < BetterLabel > me = new WeakReference<>(this);
    componentPopupMenu(this, BetterLabel_menuItems(me));
  }
  
  BetterLabel(String text) {
    this();
    this.setText(text);
  }
  
  public void setText(String text) {
    super.setText(text);
    if (autoToolTip)
      if (!swic(text, "<html>")) // HTML labels make super-huge, confusing tool tips
        setToolTipText(nullIfEmpty(text));
  }
}

// moved outside of class for GC reasons (see above)
static VF1<JPopupMenu> BetterLabel_menuItems(final WeakReference<BetterLabel> me) {
  return new VF1<JPopupMenu>() { public void get(JPopupMenu menu) { try { 
    addMenuItem(menu, "Copy text to clipboard", new Runnable() {  public void run() { try { 
      copyTextToClipboard(me.get().getText());
    
} catch (Exception __e) { throw rethrow(__e); } }  public String toString() { return "copyTextToClipboard(me.get().getText());"; }});
   } catch (Exception __e) { throw rethrow(__e); } }
  public String toString() { return "addMenuItem(menu, \"Copy text to clipboard\", r {\r\n      copyTextToClipboard(me..."; }};
}
// elements are put to front when added (not when accessed)
static class MRUCache<A, B> extends LinkedHashMap<A, B> {
  int maxSize = 10;

  MRUCache() {}
  MRUCache(int maxSize) {
  this.maxSize = maxSize;}
  
  protected boolean removeEldestEntry(Map.Entry eldest) {
    return size() > maxSize;
  }
  
  Object _serialize() {
    return ll(maxSize, cloneLinkedHashMap(this));
  }
  
  static MRUCache _deserialize(List l) {
    MRUCache m = new MRUCache();
    m.maxSize = (int) first(l);
    m.putAll((LinkedHashMap) second(l));
    return m;
  }
}

// TODO: subclass RuntimeException and use Meta instead of DynamicObject
static class PersistableThrowable extends DynamicObject {
  String className;
  String msg;
  String stacktrace;
   final public PersistableThrowable setActualThrowable(Throwable actualThrowable){ return actualThrowable(actualThrowable); }
public PersistableThrowable actualThrowable(Throwable actualThrowable) { this.actualThrowable = actualThrowable; return this; }  final public Throwable getActualThrowable(){ return actualThrowable(); }
public Throwable actualThrowable() { return actualThrowable; }
transient Throwable actualThrowable;
  
  PersistableThrowable() {}
  PersistableThrowable(Throwable e) {
    actualThrowable = e;
    if (e == null)
      className = "Crazy Null Error";
    else {
      className = getClassName(e).replace('/', '.');
      msg = e.getMessage();
      stacktrace = getStackTrace_noRecord(e);
    }
  }
  
  public String toString() {
    return nempty(msg) ? className + ": " + msg : className;
  }
  
  RuntimeException asRuntimeException() {
    if (actualThrowable != null)
      return main.asRuntimeException(actualThrowable);
    return new Fail(this);
  }
}


static class PingSourceCancelledException extends RuntimeException implements IFieldsToList{
  PingSource pingSource;
  PingSourceCancelledException() {}
  PingSourceCancelledException(PingSource pingSource) {
  this.pingSource = pingSource;}
  public String toString() { return shortClassName_dropNumberPrefix(this) + "(" + pingSource + ")"; }public Object[] _fieldsToList() { return new Object[] {pingSource}; }

}
static class ConceptWithGlobalID extends Concept implements IHasGlobalID {
  
GlobalID globalID =
  
   aGlobalIDObjUnlessLoading(); 

public GlobalID globalID() { return globalID; }
public String globalIDStr() { return strOrNull(globalID); }

String prependGlobalID(String s) { return globalID == null ? s : "[" + globalID + "] " + s; }
}
// the lockFile must be a file separate from any data files.
// It is created & deleted by this class, and will always have
// size 0.
static class FileBasedLock implements AutoCloseable {
  File lockFile;
  double timeout = 60.0; // in seconds. refresh happens twice as often
  boolean verbose = false;
  boolean haveLock = false;
  java.util.Timer touchTimer;
  
  // what to put in the lock file when we create it
   final public FileBasedLock setContentsForLockFile(String contentsForLockFile){ return contentsForLockFile(contentsForLockFile); }
public FileBasedLock contentsForLockFile(String contentsForLockFile) { this.contentsForLockFile = contentsForLockFile; return this; }  final public String getContentsForLockFile(){ return contentsForLockFile(); }
public String contentsForLockFile() { return contentsForLockFile; }
 String contentsForLockFile;
  
  FileBasedLock() {}
  FileBasedLock(File lockFile) {
  this.lockFile = lockFile;}
  FileBasedLock(File lockFile, double timeout) {
  this.timeout = timeout;
  this.lockFile = lockFile;}
  
  // returns true iff lock was acquired (or kept)
  synchronized boolean tryToLock() {
    if (haveLock) return true;
    
    if (fileExists(lockFile)) {
      double age = fileAgeInSeconds(lockFile);
      double remaining = timeout-age;
      print("Lock file age: " + lockFile + ": " + iround(age) + " s"
        + (remaining <= 0
          ? " - old, deleting"
          : " - please start again in " + nSeconds(iceil(remaining))));
        
      if (remaining <= 0) {
        print("Deleting old lock file (program crashed?): " + lockFile + " (age: " + iround(age) + " seconds)");
        deleteFile(lockFile);
      }
    }
    
    try {
      mkdirsForFile(lockFile);
      
      // This does the actual atomic file creation
      java.nio.file.Files.createFile(toPath(lockFile));
      print("Created lock file: " + lockFile);
      
      // Optionally set the lock file's contents
      if (nempty(contentsForLockFile))
        writeContents();
        
      acquired();
      return true;
    } catch (Throwable e) {
      printExceptionShort("Can't lock", e);
      return false;
    }
  }
  
  void writeContents() {
    saveTextFileWithoutTemp(lockFile, unnull(contentsForLockFile));
  }
  
  private void acquired() {
    haveLock = true;
    startTouchTimer();
  }
  
  void forceLock() { try {
    print("Force-locking " + lockFile);
    writeContents();
    acquired();
  } catch (Exception __e) { throw rethrow(__e); } }
  
  String lockError() {
    return "Couldn't aquire lock file: " + lockFile;
  }
  
  void lockOrFail() {
    if (!tryToLock())
      throw fail(lockError());
  }
  
  synchronized void startTouchTimer() {
    if (touchTimer != null) return;
    double interval = timeout/2;
    touchTimer = doEvery(interval, new Runnable() {  public void run() { try {  doTouch(); 
} catch (Exception __e) { throw rethrow(__e); } }  public String toString() { return "doTouch();"; }});
    if (verbose) print("Touch timer started for " + lockFile +  " (" + interval + "s)");
  }

  synchronized void doTouch() { try {
    if (haveLock) {
      if (verbose) print("Touching lock file: " + lockFile);
      //touchExistingFile(lockFile);
      touchFile(lockFile);
    }
  } catch (Throwable __e) { pcallFail(__e); }}
     
  public synchronized void close() { try {
    { cleanUp(touchTimer); touchTimer = null; }
    if (haveLock) {
      haveLock = false;
      if (verbose) print("Deleting lock file: " + lockFile);
      deleteFile(lockFile);
    }
  } catch (Throwable __e) { pcallFail(__e); }}
  
  synchronized void _simulateCrash() {
    { cleanUp(touchTimer); touchTimer = null; }
  }
  
  void deleteOnExit() {
    if (haveLock)
      lockFile.deleteOnExit();
  }
  
  String actualContents() {
    return loadTextFile(lockFile);
  }
  
  boolean hasExpectedContents() {
    return eq(unnull(contentsForLockFile), actualContents());
  }
}
// The idea is to leave max as the actual number of cores the system
// has (numberOfCores()), and in case of being fully booked, raise an
// alert (customerMustWaitAlert) which can be handled by a strategy
// object (different reactions are possible).
// If nothing is done in such an event, clients are processed serially
// (no guarantees of order), split up among the available threads.

/* SYNChronisation order:
      1. PooledThread
      2. ThreadPool */

static class ThreadPool implements AutoCloseable {
  int max = numberOfCores();
  List<PooledThread> all = new ArrayList();
  Set<PooledThread> used = new HashSet();
  Set<PooledThread> free = new HashSet();
  boolean verbose, retired;
  
  // our own ping surce so we can start threads & keep them running
  class InternalPingSource extends PingSource {}
  InternalPingSource internalPingSource = new InternalPingSource();
  
  MultiSleeper sleeper = new MultiSleeper();
  
  ThreadPool() {}
  ThreadPool(int max) {
  this.max = max;}
  
  synchronized int maxSize() { return max; }
  synchronized int total() { return l(used)+l(free); }
  
   transient 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); }
  
  void fireCustomerMustWaitAlert() {
    vmBus_send("customerMustWaitAlert", this, currentThread());
    customerMustWaitAlert();
  }

  // DOESN'T WAIT. adds action to a thread's queue if nothing is
  // available immediately.
  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); // will move it from free to used
    return t;
  }
  
  // run in synchronized block
  boolean _hasFreeAfterCreating() {
    checkNotRetired();
    if (nempty(free)) return true;
    if (total() < max) {
      PooledThread t = newThread();
      all.add(t);
      free.add(t);
      return true;
    }
    return false;
  }
  
  // WAITS until thread is available
  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); } }
  
  PooledThread _firstFreeThread() {
    return first(free);
  }
  
  PooledThread _anyThread() {
    return random(used);
  }
  
  class PooledThread extends Thread {
    PooledThread(String name) { super(name); }
    
    AppendableChain<Runnable> q;
    
    synchronized 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 boolean isEmpty() { return empty(q); }
    
    // append to q (do later)
    void addWork(Runnable r) {
      if (verbose) print("Added work to " + this + ": " + r);
      synchronized(this) {
        q = chainPlus(q, r);
        notifyAll();
      }
    }  
  }
  
  PooledThread newThread() {
    PooledThread t = new PooledThread("Thread Pool Inhabitant " + n2(total()+1));
    t.start();
    return t;
  }
  
  synchronized void markFree(PooledThread t) {
    used.remove(t);
    free.add(t);
    notifyAll();
  }
  
  synchronized 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 boolean retired() { return retired; }
  synchronized void retire() {
    if (verbose) print("ThreadPool Retiring");
    retired = true;
    for (var thread : free) syncNotifyAll(thread); // wake it up so it exits
  }
  void checkNotRetired() {   
    if (retired()) throw fail("retired");
  }
 
  // We could do a soft-close here (stop the idle threads, let running threads finish, then end those too, stop accepting new orders)
  // or a hard close (interrupt all threads, stop accepting new orders)
  synchronized public void close() { try {
    retire();
  } catch (Exception __e) { throw rethrow(__e); } }
  
  // run in synchronized block
  void _waitWaitWait() { try {
    do {
      fireCustomerMustWaitAlert();
      wait();
      checkNotRetired();
    } while (empty(free));
  } catch (Exception __e) { throw rethrow(__e); } }
  
  void dO(String text, Runnable r) {
    if (r == null) return;
    new PingSource(this, text).dO(r);
  }
  
  ISleeper_v2 sleeper() { return sleeper; }
}
abstract static class ConceptFieldIndexBase<A extends Concept, Val> implements IConceptIndex, IFieldIndex<A, Val>, IConceptCounter, AutoCloseable {
  Concepts concepts;
  Class<A> cc;
  String field;
  Map<A, Val> objectToValue = syncHashMap();
  MultiSetMap<Val, A> valueToObject; // initialized in subclass
  // bool indexNulls = true; // set this only when there are few null values in this field in the db. or when the point is to index a non-existing field (for singletons)
  
  ConceptFieldIndexBase() { init(); }
  ConceptFieldIndexBase(Class<A> cc, String field) { this(db_mainConcepts(), cc, field); }
  ConceptFieldIndexBase(Concepts concepts, Class<A> cc, String field) {
    this();
  this.field = field;
  this.cc = cc;
  this.concepts = concepts;
    concepts.addConceptIndex(this);
    updateAll();
    register();
    updateAll();
  }
  
  void updateAll() {
    for (A c : setToIndex())
      updateImpl(c);
  }
  
  Collection<A> setToIndex() {
    return list(concepts, cc);
  }
  
  abstract void init();
  abstract void register();

  public void update(Concept c) {
    if (!isInstance(cc, c)) return;
    updateImpl((A) c);
  }
  
  synchronized void updateImpl(A c) {
    Val newValue =  (Val) (cget(c, field));
    Val oldValue = objectToValue.get(c);
    if (newValue == oldValue && (oldValue != null || objectToValue.containsKey(c))) return;
    valueToObject.remove(oldValue, c);
    valueToObject.put(newValue, c);
    put(objectToValue, c, newValue);
  }
  
  public synchronized void remove(Concept c) {
    if (!isInstance(cc, c)) return;
    if (!objectToValue.containsKey(c)) return;
    Val value = objectToValue.get(c);
    objectToValue.remove(c);
    valueToObject.remove(value, (A) c);
  }
  
  synchronized A get(Val value) {
    return valueToObject.getFirst(value);
  }
  
  // older version - may return empty list as null
  // should be phased out everywhere!
  public synchronized Collection<A> getAll(Val value) {
    return valueToObject.get(value);
  }
  
  public synchronized List<Val> allValues() { return cloneKeys_noSync(valueToObject.data); }
  
  public IterableIterator<A> objectIterator() {
    return navigableMultiSetMapValuesIterator_concurrent(valueToObject, this);
  }
  
  public synchronized MultiSet<Val> allValues_multiSet() {
    return multiSetMapToMultiSet(valueToObject);
  }
  
  public Class<? extends Concept> conceptClass() { return cc; }
  public int countConcepts() { return l(objectToValue); }
  public Collection<Concept> allConcepts() { return (Collection) keys(objectToValue); }
  
  Object mutex() { return this; }
  
  public void close() { try {
    concepts.removeConceptIndex(this);
  } catch (Exception __e) { throw rethrow(__e); } }
}
interface IMultiMap<A, B> {
  public Set<A> keySet();
  public Collection<B> get(A a);
  public int size();
  public int keyCount();
}
// uses HashMap by default
static class MultiSet<A> implements IMultiSet<A> {
  Map<A, Integer> map = new HashMap();
  int size; // now maintaining a size counter
  
  MultiSet(boolean useTreeMap) {
    if (useTreeMap) map = new TreeMap();
  }
  MultiSet(TreeMap map) {
  this.map = map;}
  
  MultiSet() {}
  MultiSet(Iterable<A> c) { addAll(c); }
  MultiSet(MultiSet<A> ms) { synchronized(ms) {
    for (A a : ms.keySet()) add(a, ms.get(a));
  }}
  
  // returns new count
  public synchronized int add(A key) { return add(key, 1); }
  
  synchronized void addAll(Iterable<A> c) {
    if (c != null) for (A a : c) add(a);
  }

  synchronized void addAll(MultiSet<A> ms) {
    for (A a : ms.keySet()) add(a, ms.get(a));
  }
  
  synchronized int add(A key, int count) {
    if (count <= 0) return 0; // don't calculate return value in this case
    size += count;
    Integer i = map.get(key);
    map.put(key, i != null ? (count += i) : count);
    return count;
  }

  synchronized void put(A key, int count) {
    int oldCount = get(key);
    if (count == oldCount) return;
    size += count-oldCount;
    if (count != 0)
      map.put(key, count);
    else
      map.remove(key);
  }

  public synchronized int get(A key) {
    Integer i = map.get(key);
    return i != null ? i : 0;
  }
  
  synchronized boolean contains(A key) {
    return map.containsKey(key);
  }

  synchronized void remove(A key) {
    Integer i = map.get(key);
    if (i != null) {
      --size;
      if (i > 1)
        map.put(key, i - 1);
      else
        map.remove(key);
    }
  }

  synchronized List<A> topTen() { return getTopTen(); }
  
  synchronized List<A> getTopTen() { return getTopTen(10); }
  synchronized List<A> getTopTen(int maxSize) {
    List<A> list = getSortedListDescending();
    return list.size() > maxSize ? list.subList(0, maxSize) : list;
  }
  
  synchronized List<A> highestFirst() {
    return getSortedListDescending();
  }

  synchronized List<A> lowestFirst() {
    return reversedList(getSortedListDescending());
  }

  synchronized List<A> getSortedListDescending() {
    List<A> list = new ArrayList<A>(map.keySet());
    Collections.sort(list, new Comparator<A>() {
      public int compare(A a, A b) {
        return map.get(b).compareTo(map.get(a));
      }
    });
    return list;
  }

  synchronized int getNumberOfUniqueElements() {
    return map.size();
  }
  
  synchronized int uniqueSize() {
    return map.size();
  }

  synchronized Set<A> asSet() {
    return map.keySet();
  }

  synchronized NavigableSet<A> navigableSet() {
    return navigableKeys((NavigableMap) map);
  }

  public synchronized Set<A> keySet() {
    return map.keySet();
  }
  
  final  A mostPopular(){ return getMostPopularEntry(); }
synchronized A getMostPopularEntry() {
    int max = 0;
    A a = null;
    for (Map.Entry<A,Integer> entry : map.entrySet()) {
      if (entry.getValue() > max) {
        max = entry.getValue();
        a = entry.getKey();
      }
    }
    return a;
  }

  synchronized void removeAll(A key) {
    size -= get(key);
    map.remove(key);
  }

  public synchronized int size() {
    return size;
  }

  synchronized MultiSet<A> mergeWith(MultiSet<A> set) {
    MultiSet<A> result = new MultiSet<A>();
    for (A a : set.asSet()) {
      result.add(a, set.get(a));
    }
    return result;
  }
  
  public synchronized boolean isEmpty() {
    return map.isEmpty();
  }
  
  synchronized public String toString() { // hmm. sync this?
    return str(map);
  }
  
  synchronized void clear() {
    map.clear();
    size = 0;
  }
  
  final  Map<A, Integer> toMap(){ return asMap(); }
synchronized Map<A, Integer> asMap() {
    return cloneMap(map);
  }
}
static class StandaloneHttpProxy implements AutoCloseable {
  boolean debug = false;
  boolean serveLocalhostOnly = false; // IMPORTANT if you need it!
  boolean sendXProying = true;
  int port = 8443;
  boolean rewriteHostHeader = true; // Send a modified Host header
  int upBufSize = 1; // otherwise POST seems to break...
  int downBufSize = 1024;
  
  Set<String> blockedIPs = syncSet();
  
  // set or override this!
  transient  IF1<Request, HostAndPort> forwardServerAndPort;
HostAndPort forwardServerAndPort(Request req) { return forwardServerAndPort != null ? forwardServerAndPort.get(req) : forwardServerAndPort_base(req); }
final HostAndPort forwardServerAndPort_fallback(IF1<Request, HostAndPort> _f, Request req) { return _f != null ? _f.get(req) : forwardServerAndPort_base(req); }
HostAndPort forwardServerAndPort_base(Request req) { return null; }
  
  // can set or override this for https
  transient  IF0<ServerSocket> makeServerSocket;
ServerSocket makeServerSocket() { return makeServerSocket != null ? makeServerSocket.get() : makeServerSocket_base(); }
final ServerSocket makeServerSocket_fallback(IF0<ServerSocket> _f) { return _f != null ? _f.get() : makeServerSocket_base(); }
ServerSocket makeServerSocket_base() {
    { try { return new ServerSocket(port); } catch (Exception __e) { throw rethrow(__e); } }
  }
  
  // internal
  Thread acceptThread;
  ServerSocket serverSocket;

  void start() throws IOException {
    serverSocket = makeServerSocket();

    acceptThread = startThread("HTTP Proxy Accept Port " + port, new Runnable() {  public void run() { try {  acceptLoop(); 
} catch (Exception __e) { throw rethrow(__e); } }  public String toString() { return "acceptLoop();"; }});
    print("HTTP proxy on port " + port + " started."); 
  }
  
  void acceptLoop() throws IOException {
    while (true) {
      try {
        Socket s = serverSocket.accept();
        new Request(s).run();
      } catch (SocketTimeoutException e) {
      }
    }
  }

  transient  IF1<String, String> rewriteHeaderLine;
String rewriteHeaderLine(String line) { return rewriteHeaderLine != null ? rewriteHeaderLine.get(line) : rewriteHeaderLine_base(line); }
final String rewriteHeaderLine_fallback(IF1<String, String> _f, String line) { return _f != null ? _f.get(line) : rewriteHeaderLine_base(line); }
String rewriteHeaderLine_base(String line) { return line; }
  
  static void headerSend(OutputStream out, String header) { try {
    print("Sending header: " + header);
    out.write((header + "\r\n").getBytes("US-ASCII"));
  } catch (Exception __e) { throw rethrow(__e); } }
  
  public void close() { try { { cleanUp(serverSocket); serverSocket = null; } } catch (Exception __e) { throw rethrow(__e); } }
  
  class Request implements AutoCloseable {
    Socket s; // client socket
    String client;
    boolean blocked = false;
    Socket outSocket;
    
    // TODO: Values may be inaccurate when there is stream rewriting
    //   by overriding outProxied and/or outOutProxied.
    AtomicLong transmitted = new AtomicLong();
    AtomicLong outTransmitted = new AtomicLong();
    
    String threadName = "StandaloneHttpProxy";
    Thread thread, inThread, outThread;
    OutputStream outDirect, outOutDirect;
    OutputStream outProxied, outOutProxied;
    InputStream in, outIn;
    MultiMap<String, String> incomingHeaders = ciMultiMap();
    boolean forwardedFor = false;
    String host;
    ByteArrayOutputStream headersOut = new ByteArrayOutputStream();
    boolean headersRead = false;
    CloseablesHolder resources = new CloseablesHolder();
    
    Request(Socket s) {
  this.s = s;}
    Request(Socket s, InputStream in, OutputStream out) {
  this.in = in;
  this.s = s; setOut(out); }
    
    transient  IVF1<OutputStream> setOut;
void setOut(OutputStream out) { if (setOut != null) setOut.get(out); else setOut_base(out); }
final void setOut_fallback(IVF1<OutputStream> _f, OutputStream out) { if (_f != null) _f.get(out); else setOut_base(out); }
void setOut_base(OutputStream out) {
      outDirect = outProxied = out;
    }
    
    transient  IVF1<OutputStream> setOutOut;
void setOutOut(OutputStream outOut) { if (setOutOut != null) setOutOut.get(outOut); else setOutOut_base(outOut); }
final void setOutOut_fallback(IVF1<OutputStream> _f, OutputStream outOut) { if (_f != null) _f.get(outOut); else setOutOut_base(outOut); }
void setOutOut_base(OutputStream outOut) {
      outOutDirect = outOutProxied = outOut;
    }
    
    public void run() { try {
      try {
        client = dropPrefix("/", s.getInetAddress().toString()); // Hmm... how to get the actual IP properly?
        
        if (serveLocalhostOnly && !socketIsLocalhost(s)) {
          print("Dropping non-localhost connection from " + client); 
          { close(); return; }
        }
        
        threadName = "PROXY: Handling client " + client;
          
        if (blocked = blockedIPs.contains(client)) {
          print("Blocked IP!! " + client);
          { close(); return; }
        }
  
        run2();
      } catch (Throwable e) { print("Closing because of: " + e);
        close();
      
throw rethrow(e); }
    } catch (Exception __e) { throw rethrow(__e); } } // Request.run
    
    void run2() {
      try {
        thread = startDaemonThread(threadName, new Runnable() {  public void run() { try {  handleIt_impl(); 
} catch (Exception __e) { throw rethrow(__e); } }  public String toString() { return "handleIt_impl();"; }});
      } catch (Throwable e) { print("Closing because of: " + e);
        close();
      
throw rethrow(e); }
    }
    
    void handleIt_impl() throws IOException {
      try {
        print("HTTP Proxy Incoming!");
        
        if (outDirect == null) setOut(s.getOutputStream());
        if (in == null) in = s.getInputStream();
        
        // collect headers
        
        if (!headersRead) while (true) {
          String line = readHttpHeaderLine(in);
          if (line == null) return;
          print("Header line read: " + quote(line));
          
          int i = indexOf(line, ':');
          if (i >= 0)
            incomingHeaders.put(trim(takeFirst(i, line)), trim(dropFirst(i+1, line)));
          
          boolean isHostLine = swic(line, "Host:");
          if (isHostLine)
            host = dropPrefixIgnoreCase("Host:", line).trim();
            
          if (!isHostLine || !rewriteHostHeader) {
            String rewritten;
            if (startsWithIgnoreCase(line, "X-Forwarded-For:")) {
              forwardedFor = true;
              rewritten = line + ", " + client;
            } else
              rewritten = empty(line) ? line : rewriteHeaderLine(line);
            if (!eq(rewritten, line))
              print("Rewritten as: " + quote(rewritten));
            if (nempty(rewritten)) {
              byte[] bytes = (rewritten + "\r\n").getBytes("US-ASCII");
              //print("Sending: " + bytesToHex(bytes));
              headersOut.write(bytes);
            }
          }
          
          if (l(line) == 0)
            break;
        }
        
        HostAndPort hap = forwardServerAndPort(this);
        if (hap == null || empty(hap.host) || hap.port == 0)
          { print("Can't forward request"); return; }
          
        String forwardServer = hap.host;  
        int port = hap.port;
        
        outSocket = new Socket(forwardServer, port);
        print("Connected to " + forwardServer + ":" + port);
        outOutDirect = outOutProxied = outSocket.getOutputStream();
        outIn = outSocket.getInputStream();
        
        byte[] headerBytes = headersOut.toByteArray();
        if (containsLine(fromUtf8(headerBytes), "X-Proxying: yes"))
          { print("Won't double-proxy"); return; }
          
        outOutProxied.write(headerBytes);
        
        if (!forwardedFor)
          headerSend(outOutProxied, "X-Forwarded-For: " + client);
          
        if (rewriteHostHeader)
          headerSend(outOutProxied, "Host: " + addPortToHost_drop80(host, port));
        
        if (sendXProying)
          headerSend(outOutProxied, "X-Proxying: yes");
          
        headerSend(outOutProxied, "X-OriginalPort: " + s.getLocalPort());
        
        headerSend(outOutProxied, ""); // end of headers
          
        outOutProxied.flush();
        
        // forward content in both directions
        
        inThread = startThread("Proxy In", new Runnable() {  public void run() { try {  proxyIn_impl(); 
} catch (Exception __e) { throw rethrow(__e); } }  public String toString() { return "proxyIn_impl();"; }});
        outThread = startThread("Proxy Out", new Runnable() {  public void run() { try {  proxyOut_impl(); 
} catch (Exception __e) { throw rethrow(__e); } }  public String toString() { return "proxyOut_impl();"; }});
        
        joinThreads(inThread, outThread);
      } catch (Exception e) {
        if (isIOException(e))
          print("[internal] " + e);
        else
          print("stack exit: " + renderStackTrace(e));
      } finally {
        print("Request done");
        close();
      }
    } // end of handleIt_impl
    
    void proxyIn_impl() throws IOException {
      try {
        byte[] buf = new byte[downBufSize];
        while (true) {
          int n = outIn.read(buf);
          if (n <= 0) { print("proxyIn: n=" + n); return; }
          outProxied.write(buf, 0, n);
          long t = transmitted.addAndGet(n);
          if (t % 100000 == 0) print("Transmitted to client: " + t);
        }
      } finally {
        print("Server closed stream, shutting down client output.");
        s.shutdownOutput();
      }
    }

    void proxyOut_impl() throws IOException {
      try {
        print("Proxy Out started.");
        byte[] buf = new byte[upBufSize];
        while (true) {
          int n = in.read(buf);
          if (n <= 0) { print("proxyOut: n=" + n); return; }
          outOutProxied.write(buf, 0, n);
          if (outTransmitted.get() == 0)
            print("Proxy Out first byte!");
          long t = outTransmitted.addAndGet(n);
          if (t % (debug ? 10 : 100000) == 0) print("Transmitted to server: " + t);
        }
      } finally {
        print("Client closed stream, shutting down server output.");
        outSocket.shutdownOutput();
      }
    }
    
    public void close() { try {
      if (s == null && outSocket == null) return;
      
      print("Proxy request done, got " + transmitted.get() + ", sent " + outTransmitted.get() + " + headers");
      { cleanUp(s); s = null; }
      { cleanUp(outSocket); outSocket = null; }
      { cleanUp(resources); resources = null; }
    } catch (Exception __e) { throw rethrow(__e); } }
  } // end of Request
  
  Request takeOverIncomingSocket(String host, Socket socket, InputStream in, OutputStream out, byte[] headers) throws IOException {
    return takeOverIncomingSocket(host, socket, in, out, null);
  }

  // rewriteHostHeader should be false when you use this method  
  Request takeOverIncomingSocket(String host, Socket socket, InputStream in, OutputStream out, byte[] headers, IVF1<Request> customize) throws IOException {
    Request r = new Request(socket, in, out);
    r.host = host;
    r.headersOut.write(headers);
    
    // various flags to read no more headers
    // & send just the headers we received
    r.headersRead = true; 
    r.forwardedFor = true;
    
    callF(customize, r);
    
    r.run2();
    return r;
  }
}
static interface IWebRequest {
  public String uri();
  public Map<String, String> params();
  public Map<String, String> headers();
  public Map<String, String> files();
  
  default public String clientIP() {
    return unnull(getClientIPFromHeaders(headers()));
  }
  
  default public String getHeader(String name) { return mapGet(headers(), name); }

  default public String domain() {
    return getHeader("host");
  }

  public String cookie();
  
  public boolean isHttps();
  
  public boolean isPost();
  
  default String protocol() { return isHttps() ? "https://" : "http://"; }
  
  // mark this request as no-spam (don't count towards spam limit)
  default void noSpam() {}
  
  default String get(String param) { return mapGet(params(), param); }
  
  default String userAgent() { return getHeader("user-agent"); }
  
  // proxy another page
  default Object proxy(String url, boolean rewriteHost, boolean rewritePort) { throw unimplemented(); }
  
  default boolean uriIs(String uri) {
    return eq(uri(), uri);
  }
  
  default boolean uriIsIC(String uri) {
    return eqic(uri(), uri);
  }
  
  default String postData() {
    return mapGet(files(), "postData");
  }
}
static class MinimalChain<A> implements Iterable<A> {
  A element;
  MinimalChain<A> next;

  MinimalChain() {}
  MinimalChain(A element) {
  this.element = element;}
  MinimalChain(A element, MinimalChain<A> next) {
  this.next = next;
  this.element = element;}
  
  public String toString() { return str(toList()); }
  
  ArrayList<A> toList() {
    ArrayList<A> l = new ArrayList();
    MinimalChain<A> c = this;
    while (c != null) {
      l.add(c.element);
      c = c.next;
    }
    return l;
  }
  
  void setElement(A a) { element = a; }
  void setNext(MinimalChain<A> next) { this.next = next; }
  
  // TODO: optimize
  public Iterator<A> iterator() { return toList().iterator(); }
  
  A get() { return element; }
}
static interface ISetter<A> {
 void set(A a);
}

static interface IConceptCounter {
  Class<? extends Concept> conceptClass();
  int countConcepts();
  Collection<Concept> allConcepts();
}
interface IBest<A> {
  boolean put(A a, double score);
}
static interface IAutoCloseableF0<A> extends IF0<A>, AutoCloseable {}
/*
 * #!
 * Ontopia Engine
 * #-
 * Copyright (C) 2001 - 2013 The Ontopia Project
 * #-
 * Licensed under the Apache License, Version 2.0 (the "License");
 * you may not use this file except in compliance with the License.
 * You may obtain a copy of the License at
 * 
 *      http://www.apache.org/licenses/LICENSE-2.0
 * 
 * Unless required by applicable law or agreed to in writing, software
 * distributed under the License is distributed on an "AS IS" BASIS,
 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
 * See the License for the specific language governing permissions and
 * limitations under the License.
 * !#
 */

// modified by Stefan Reich

// Implements the Set interface more compactly than
// java.util.HashSet by using a closed hashtable.

// Note: equals is always called on the _stored_ object, not the one
// passed as an argument to find(), contains() etc.
// (In case you want to put special magic in your equals() function)

static class UnsynchronizedCompactHashSet<A> extends java.util.AbstractSet<A> {
  protected final static int INITIAL_SIZE = 3;
  public final static double LOAD_FACTOR = 0.75;

  protected final static Object nullObject = new Object();
  protected final static Object deletedObject = new Object();
  protected int elements;
  protected int freecells;
  protected A[] objects;
  
  protected int modCount;
  
  
  UnsynchronizedCompactHashSet() {
    this(INITIAL_SIZE);
  }

  UnsynchronizedCompactHashSet(int size) {
    // NOTE: If array size is 0, we get a
    // "java.lang.ArithmeticException: / by zero" in add(Object).
    objects = (A[]) new Object[(size==0 ? 1 : size)];
    elements = 0;
    freecells = objects.length;
    
      modCount = 0;
    
  }

  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;
  }
  
  A find(Object o) {
    if (o == null) o = nullObject;
    
    int hash = o.hashCode();
    int index = (hash & 0x7FFFFFFF) % objects.length;
    int offset = 1;

    // search for the object (continue while !null and !this object)
    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];
  }
  
  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;
    
    // search for the object (continue while !null and !this object)
    while(objects[index] != null &&
          !(objects[index].hashCode() == hash &&
            objects[index].equals(o))) {

      // if there's a deleted object here we can put this object here,
      // provided it's not in here somewhere else already
      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) { // wasn't present already
      if (deletedix != -1) // reusing a deleted cell
        index = deletedix;
      else
        freecells--;

      
        modCount++;
      
      elements++;

      // here we face a problem regarding generics:
      // add(A o) is not possible because of the null Object. We cant do 'new A()' or '(A) new Object()'
      // so adding an empty object is a problem here
      // If (! o instanceof A) : This will cause a class cast exception
      // If (o instanceof A) : This will work fine

      objects[index] = (A) o;
      
      // do we need to rehash?
      if (1 - (freecells / (double) objects.length) > LOAD_FACTOR)
        rehash();
      return true;
    } else // was there already 
      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;
    
    // search for the object (continue while !null and !this object)
    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;
    }

    // we found the right position, now do the removal
    if (objects[index] != null) {
      // we found the object

      // same problem here as with add
      objects[index] = (A) deletedObject;
      
        modCount++;
      
      elements--;
      return true;
    } else
      // we did not find the object
      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];
      }
    // unchecked because it should only contain A
    return result;
  }

  // not sure if this needs to have generics
  @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;
  }
  
  protected void rehash() {
    int garbagecells = objects.length - (elements + freecells);
    if (garbagecells / (double) objects.length > 0.05)
      // rehash with same size
      rehash(objects.length);
    else
      // rehash with increased capacity
      rehash(objects.length*2 + 1);
  }
  
  protected 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;

      // search for the object
      while(newObjects[index] != null) { // no need to test for duplicates
        index = ((index + offset) & 0x7FFFFFFF) % newCapacity;
        offset = offset*2 + 1;

        if (offset == -1)
          offset = 2;
      }

      newObjects[index] = (A) o;
    }

    objects = newObjects;
    freecells = objects.length - elements;
  }
  
  private class CompactHashIterator<T> implements Iterator<T> {
    private int index;
    private int lastReturned = -1;

    
      private 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() {
        /*if (modCount != expectedModCount)
          throw new ConcurrentModificationException();*/
        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();
        // delete object
        if (objects[lastReturned] != null && objects[lastReturned] != deletedObject) {
          objects[lastReturned] = (A) deletedObject;
          elements--;
          
            modCount++;
            expectedModCount = modCount; // this is expected; we made the change
          
        }
    }
  }
  
  int capacity() { return objects.length; }
  
  // returns true if there was a shrink
  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 class RemoteDB implements AutoCloseable {
  DialogIO db;
  String name;
  
  // s = bot name or snippet ID
  RemoteDB(String s) {
    this(s, false);
  }
  
  RemoteDB(String s, boolean autoStart) {
    name = s;
    if (isSnippetID(s)) name = dbBotName(s);
    db = findBot(name);
    if (db == null)
      if (autoStart) {
        nohupJavax(fsI(s));
        waitForBotStartUp(name);
        assertNotNull("Weird problem", db = findBot(s));
      } else
        throw fail("DB " + s + " not running");
  }

  boolean functional() { return db != null; } // now always true
  
  List<RC> list() { return adopt((List<RC>) rpc(db, "xlist")); }
  List<RC> list(String className) { return adopt((List<RC>) rpc(db, "xlist", className)); }
  List<RC> xlist() { return list(); }
  List<RC> xlist(String className) { return list(className); }
  
  // adopt is an internal method
  List<RC> adopt(List<RC> l) {
    if (l != null) for (RC rc : l) adopt(rc);
    return l;
  }
  
  RC adopt(RC rc) { if (rc != null) rc.db = this; return rc; }
  
  Object adopt(Object o) {
    if (o instanceof RC) return adopt((RC) o);
    return o;
  }
  
  String xclass(RC o) {
    return (String) rpc(db, "xclass", o);
  }
  
  Object xget(RC o, String field) {
    return adopt(rpc(db, "xget", o, field));
  }
  
  String xS(RC o, String field) {
    return (String) xget(o, field);
  }
  
  RC xgetref(RC o, String field) {
    return adopt((RC) xget(o, field));
  }
  
  void xset(RC o, String field, Object value) {
    rpc(db, "xset", o, field, value);
  }
  
  RC uniq(String className) {
    RC ref = first(list(className));
    if (ref == null)
      ref = xnew(className);
    return ref;
  }
  RC xuniq(String className) { return uniq(className); }
  
  RC xnew(String className, Object... values) {
    return adopt((RC) rpc(db, "xnew", className, values));
  }
  
  void xdelete(RC o) {
    rpc(db, "xdelete", o);
  }
  
  void xdelete(List<RC> l) {
    rpc(db, "xdelete", l);
  }

  public void close() {
    _close(db);
  }
  
  String fullgrab() { return (String) rpc(db, "xfullgrab"); }
  String xfullgrab() { return fullgrab(); }
  
  void xshutdown() { rpc(db, "xshutdown"); }
  
  long xchangeCount() { return (long) rpc(db, "xchangeCount"); }
  int xcount() { return (int) rpc(db, "xcount"); }

  void reconnect() {
    close();
    db = findBot(name);
  }
  
  RC rc(long id) { return new RC(this, id); }
}
// from https://android.googlesource.com/platform/external/nanohttpd/+/42ff2a9/websocket/src/main/java/fi/iki/elonen/




static boolean webSocket_debug = false;

static class WebSocketException extends IOException {
    private WebSocketFrame.CloseCode code;
    private String reason;
    public WebSocketException(Exception cause) {
        this(WebSocketFrame.CloseCode.InternalServerError, cause.toString(), cause);
    }
    public WebSocketException(WebSocketFrame.CloseCode code, String reason) {
        this(code, reason, null);
    }
    public WebSocketException(WebSocketFrame.CloseCode code, String reason, Exception cause) {
        super(code + ": " + reason, cause);
        this.code = code;
        this.reason = reason;
    }
    public WebSocketFrame.CloseCode getCode() {
        return code;
    }
    public String getReason() {
        return reason;
    }
}

static class WebSocketFrame {
    private OpCode opCode;
    private boolean fin = false;
    private byte[] maskingKey;
    private byte[] payload;
    private transient int _payloadLength;
    private transient String _payloadString;
    private WebSocketFrame(OpCode opCode, boolean fin) {
        setOpCode(opCode);
        setFin(fin);
    }
    public WebSocketFrame(OpCode opCode, boolean fin, byte[] payload, byte[] maskingKey) {
        this(opCode, fin);
        setMaskingKey(maskingKey);
        setBinaryPayload(payload);
    }
    public WebSocketFrame(OpCode opCode, boolean fin, byte[] payload) {
        this(opCode, fin, payload, null);
    }
    public WebSocketFrame(OpCode opCode, boolean fin, String payload, byte[] maskingKey) throws CharacterCodingException {
        this(opCode, fin);
        setMaskingKey(maskingKey);
        setTextPayload(payload);
    }
    public WebSocketFrame(OpCode opCode, boolean fin, String payload) throws CharacterCodingException {
        this(opCode, fin, payload, null);
    }
    public WebSocketFrame(WebSocketFrame clone) {
        setOpCode(clone.getOpCode());
        setFin(clone.isFin());
        setBinaryPayload(clone.getBinaryPayload());
        setMaskingKey(clone.getMaskingKey());
    }
    public WebSocketFrame(OpCode opCode, List<WebSocketFrame> fragments) throws WebSocketException {
        setOpCode(opCode);
        setFin(true);
        long _payloadLength = 0;
        for (WebSocketFrame inter : fragments) {
            _payloadLength += inter.getBinaryPayload().length;
        }
        if (webSocket_debug)
          print("Payload length with " + nFragments(fragments) + ": " + _payloadLength);
        if (_payloadLength < 0 || _payloadLength > Integer.MAX_VALUE) {
            throw new WebSocketException(WebSocketFrame.CloseCode.MessageTooBig, "Max frame length has been exceeded.");
        }
        this._payloadLength = (int) _payloadLength;
        byte[] payload = new byte[this._payloadLength];
        int offset = 0;
        for (WebSocketFrame inter : fragments) {
            System.arraycopy(inter.getBinaryPayload(), 0, payload, offset, inter.getBinaryPayload().length);
            offset += inter.getBinaryPayload().length;
        }
        setBinaryPayload(payload);
    }
    // --------------------------------GETTERS---------------------------------
    public OpCode getOpCode() {
        return opCode;
    }
    public void setOpCode(OpCode opcode) {
        this.opCode = opcode;
    }
    public boolean isFin() {
        return fin;
    }
    public void setFin(boolean fin) {
        this.fin = fin;
    }
    public boolean isMasked() {
        return maskingKey != null && maskingKey.length == 4;
    }
    public byte[] getMaskingKey() {
        return maskingKey;
    }
    public void setMaskingKey(byte[] maskingKey) {
        if (maskingKey != null && maskingKey.length != 4) {
            throw new IllegalArgumentException("MaskingKey " + Arrays.toString(maskingKey) + " hasn't length 4");
        }
        this.maskingKey = maskingKey;
    }
    public void setUnmasked() {
        setMaskingKey(null);
    }
    public byte[] getBinaryPayload() {
        return payload;
    }
    public void setBinaryPayload(byte[] payload) {
        this.payload = payload;
        this._payloadLength = payload.length;
        this._payloadString = null;
    }
    public String getTextPayload() {
        if (_payloadString == null) {
            try {
                _payloadString = binary2Text(getBinaryPayload());
            } catch (CharacterCodingException e) {
                throw new RuntimeException("Undetected CharacterCodingException", e);
            }
        }
        return _payloadString;
    }
    public void setTextPayload(String payload) throws CharacterCodingException {
        this.payload = text2Binary(payload);
        //this._payloadLength = payload.length(); // buggy!
        this._payloadLength = this.payload.length;
        if (webSocket_debug) print("payload length: " + _payloadLength + ", string length: " + l(payload)); // XXX
        this._payloadString = payload;
    }
    // --------------------------------SERIALIZATION---------------------------
    public static WebSocketFrame read(InputStream in) throws IOException {
        byte head = (byte) checkedRead(in.read());
        boolean fin = ((head & 0x80) != 0);
        OpCode opCode = OpCode.find((byte) (head & 0x0F));
        if ((head & 0x70) != 0) {
            throw new WebSocketException(WebSocketFrame.CloseCode.ProtocolError, "The reserved bits (" + Integer.toBinaryString(head & 0x70) + ") must be 0.");
        }
        if (opCode == null) {
            throw new WebSocketException(WebSocketFrame.CloseCode.ProtocolError, "Received frame with reserved/unknown opcode " + (head & 0x0F) + ".");
        } else if (opCode.isControlFrame() && !fin) {
            throw new WebSocketException(WebSocketFrame.CloseCode.ProtocolError, "Fragmented control frame.");
        }
        WebSocketFrame frame = new WebSocketFrame(opCode, fin);
        frame.readPayloadInfo(in);
        frame.readPayload(in);
        if (frame.getOpCode() == WebSocketFrame.OpCode.Close) {
            return new WebSocketFrame.CloseFrame(frame);
        } else {
            return frame;
        }
    }
    private static int checkedRead(int read) throws IOException {
        if (read < 0) {
            throw new EOFException();
        }
        //System.out.println(Integer.toBinaryString(read) + "/" + read + "/" + Integer.toHexString(read));
        return read;
    }
    private void readPayloadInfo(InputStream in) throws IOException {
        byte b = (byte) checkedRead(in.read());
        boolean masked = ((b & 0x80) != 0);
        _payloadLength = (byte) (0x7F & b);
        if (_payloadLength == 126) {
            // checkedRead must return int for this to work
            _payloadLength = (checkedRead(in.read()) << 8 | checkedRead(in.read())) & 0xFFFF;
            if (_payloadLength < 126) {
                throw new WebSocketException(WebSocketFrame.CloseCode.ProtocolError, "Invalid data frame 2byte length. (not using minimal length encoding)");
            }
        } else if (_payloadLength == 127) {
            long _payloadLength = ((long) checkedRead(in.read())) << 56 |
                    ((long) checkedRead(in.read())) << 48 |
                    ((long) checkedRead(in.read())) << 40 |
                    ((long) checkedRead(in.read())) << 32 |
                    checkedRead(in.read()) << 24 | checkedRead(in.read()) << 16 | checkedRead(in.read()) << 8 | checkedRead(in.read());
            if (_payloadLength < 65536) {
                throw new WebSocketException(WebSocketFrame.CloseCode.ProtocolError, "Invalid data frame 4byte length. (not using minimal length encoding)");
            }
            if (_payloadLength < 0 || _payloadLength > Integer.MAX_VALUE) {
                throw new WebSocketException(WebSocketFrame.CloseCode.MessageTooBig, "Max frame length has been exceeded.");
            }
            this._payloadLength = (int) _payloadLength;
        }
        if (opCode.isControlFrame()) {
            if (_payloadLength > 125) {
                throw new WebSocketException(WebSocketFrame.CloseCode.ProtocolError, "Control frame with payload length > 125 bytes.");
            }
            if (opCode == OpCode.Close && _payloadLength == 1) {
                throw new WebSocketException(WebSocketFrame.CloseCode.ProtocolError, "Received close frame with payload len 1.");
            }
        }
        if (masked) {
            maskingKey = new byte[4];
            int read = 0;
            while (read < maskingKey.length) {
                read += checkedRead(in.read(maskingKey, read, maskingKey.length - read));
            }
        }
    }
    private void readPayload(InputStream in) throws IOException {
        payload = new byte[_payloadLength];
        int read = 0;
        while (read < _payloadLength) {
            read += checkedRead(in.read(payload, read, _payloadLength - read));
        }
        if (isMasked()) {
            for (int i = 0; i < payload.length; i++) {
                payload[i] ^= maskingKey[i % 4];
            }
        }
        //Test for Unicode errors
        if (getOpCode() == WebSocketFrame.OpCode.Text) {
            _payloadString = binary2Text(getBinaryPayload());
        }
    }
    public void write(OutputStream out) throws IOException {
        byte header = 0;
        if (fin) {
            header |= 0x80;
        }
        header |= opCode.getValue() & 0x0F;
        out.write(header);
        _payloadLength = getBinaryPayload().length;
        if (_payloadLength <= 125) {
          if (webSocket_debug)
            print("Sending short payload: " + _payloadLength);
          out.write(isMasked() ? 0x80 | (byte) _payloadLength : (byte) _payloadLength);
        } else if (_payloadLength <= 0xFFFF) {
            out.write(isMasked() ? 0xFE : 126);
            out.write(_payloadLength >>> 8);
            out.write(_payloadLength);
        } else {
            out.write(isMasked() ? 0xFF : 127);
            out.write(_payloadLength >>> 56 & 0); //integer only contains 31 bit
            out.write(_payloadLength >>> 48 & 0);
            out.write(_payloadLength >>> 40 & 0);
            out.write(_payloadLength >>> 32 & 0);
            out.write(_payloadLength >>> 24);
            out.write(_payloadLength >>> 16);
            out.write(_payloadLength >>> 8);
            out.write(_payloadLength);
        }
        if (isMasked()) {
            out.write(maskingKey);
            for (int i = 0; i < _payloadLength; i++) {
                out.write(getBinaryPayload()[i] ^ maskingKey[i % 4]);
            }
        } else {
            out.write(getBinaryPayload());
        }
        out.flush();
    }
    // --------------------------------ENCODING--------------------------------
    public static final Charset TEXT_CHARSET = Charset.forName("UTF-8");
    public static String binary2Text(byte[] payload) throws CharacterCodingException {
        return new String(payload, TEXT_CHARSET);
    }
    public static String binary2Text(byte[] payload, int offset, int length) throws CharacterCodingException {
      return new String(payload, offset, length, TEXT_CHARSET);
    }
    public static byte[] text2Binary(String payload) throws CharacterCodingException {
      return payload.getBytes(TEXT_CHARSET);
    }
    @Override
    public String toString() {
        final StringBuilder sb = new StringBuilder("WS[");
        sb.append(getOpCode());
        sb.append(", ").append(isFin() ? "fin" : "inter");
        sb.append(", ").append(isMasked() ? "masked" : "unmasked");
        sb.append(", ").append(payloadToString());
        sb.append(']');
        return sb.toString();
    }
    protected String payloadToString() {
        if (payload == null) return "null";
        else {
            final StringBuilder sb = new StringBuilder();
            sb.append('[').append(payload.length).append("b] ");
            if (getOpCode() == WebSocketFrame.OpCode.Text) {
                String text = getTextPayload();
                if (text.length() > 100)
                    sb.append(text.substring(0, 100)).append("...");
                else
                    sb.append(text);
            } else {
                sb.append("0x");
                for (int i = 0; i < Math.min(payload.length, 50); ++i)
                    sb.append(Integer.toHexString((int) payload[i] & 0xFF));
                if (payload.length > 50)
                    sb.append("...");
            }
            return sb.toString();
        }
    }
    // --------------------------------CONSTANTS-------------------------------
    public static enum OpCode {
        Continuation(0), Text(1), Binary(2), Close(8), Ping(9), Pong(10);
        private final byte code;
        private OpCode(int code) {
            this.code = (byte) code;
        }
        public byte getValue() {
            return code;
        }
        public boolean isControlFrame() {
            return this == Close || this == Ping || this == Pong;
        }
        public static OpCode find(byte value) {
            for (OpCode opcode : values()) {
                if (opcode.getValue() == value) {
                    return opcode;
                }
            }
            return null;
        }
    }
    
    public static enum CloseCode {
        NormalClosure(1000), GoingAway(1001), ProtocolError(1002), UnsupportedData(1003), NoStatusRcvd(1005),
        AbnormalClosure(1006), InvalidFramePayloadData(1007), PolicyViolation(1008), MessageTooBig(1009),
        MandatoryExt(1010), InternalServerError(1011), TLSHandshake(1015);
        private final int code;
        private CloseCode(int code) {
            this.code = code;
        }
        public int getValue() {
            return code;
        }
        public static WebSocketFrame.CloseCode find(int value) {
            for (WebSocketFrame.CloseCode code : values()) {
                if (code.getValue() == value) {
                    return code;
                }
            }
            return null;
        }
    }
    // ------------------------------------------------------------------------
 public static class CloseFrame extends WebSocketFrame {
        private CloseCode _closeCode;
        private String _closeReason;
        private CloseFrame(WebSocketFrame wrap) throws CharacterCodingException {
            super(wrap);
            assert wrap.getOpCode() == OpCode.Close;
            if (wrap.getBinaryPayload().length >= 2) {
                _closeCode = CloseCode.find((wrap.getBinaryPayload()[0] & 0xFF) << 8 |
                        (wrap.getBinaryPayload()[1] & 0xFF));
                _closeReason = binary2Text(getBinaryPayload(), 2, getBinaryPayload().length - 2);
            }
        }
        public CloseFrame(CloseCode code, String closeReason) throws CharacterCodingException {
            super(OpCode.Close, true, generatePayload(code, closeReason));
        }
        private static byte[] generatePayload(CloseCode code, String closeReason) throws CharacterCodingException {
            if (code != null) {
                byte[] reasonBytes = text2Binary(closeReason);
                byte[] payload = new byte[reasonBytes.length + 2];
                payload[0] = (byte) ((code.getValue() >> 8) & 0xFF);
                payload[1] = (byte) ((code.getValue()) & 0xFF);
                System.arraycopy(reasonBytes, 0, payload, 2, reasonBytes.length);
                return payload;
            } else {
                return new byte[0];
            }
        }
        protected String payloadToString() {
            return (_closeCode != null ? _closeCode : "UnknownCloseCode[" + _closeCode + "]") + (_closeReason != null && !_closeReason.isEmpty() ? ": " + _closeReason : "");
        }
        public CloseCode getCloseCode() {
            return _closeCode;
        }
        public String getCloseReason() {
            return _closeReason;
        }
    }
}

static class WebSocket implements AutoCloseable {
  volatile Object userObject;
  
    protected final InputStream in;
    protected /*final*/ OutputStream out;
    protected WebSocketFrame.OpCode continuousOpCode = null;
    protected List<WebSocketFrame> continuousFrames = new LinkedList<WebSocketFrame>();
    protected State state = State.UNCONNECTED;
    public static enum State {
        UNCONNECTED, CONNECTING, OPEN, CLOSING, CLOSED
    }
    protected final NanoHTTPD.IHTTPSession handshakeRequest;
    //protected final NanoHTTPD.Response handshakeResponse = new NanoHTTPD.Response(NanoHTTPD.Status.SWITCH_PROTOCOL, null, (InputStream) null) {
    protected final NanoHTTPD.Response handshakeResponse = new NanoHTTPD.Response(NanoHTTPD.Status.SWITCH_PROTOCOL, null, (InputStream) null, -1) {
        @Override
        protected void send(OutputStream out) {
            WebSocket.this.out = out;
            state = State.CONNECTING;
            super.send(out);
            state = State.OPEN;
            onOpen();
            readWebsocket();
        }
    };
    public WebSocket(NanoHTTPD.IHTTPSession handshakeRequest) {
        this.handshakeRequest = handshakeRequest;
        this.in = handshakeRequest.getInputStream();
        handshakeResponse.addHeader(NanoWebSocketServer.HEADER_UPGRADE, NanoWebSocketServer.HEADER_UPGRADE_VALUE);
        handshakeResponse.addHeader(NanoWebSocketServer.HEADER_CONNECTION, NanoWebSocketServer.HEADER_CONNECTION_VALUE);
    }
    // --------------------------------IO--------------------------------------
    protected void readWebsocket() {
        try {
            while (state == State.OPEN) {
                handleWebsocketFrame(WebSocketFrame.read(in));
            }
        } catch (CharacterCodingException e) {
            onException(e);
            doClose(WebSocketFrame.CloseCode.InvalidFramePayloadData, e.toString(), false);
        } catch (IOException e) {
            onException(e);
            if (e instanceof WebSocketException) {
                doClose(((WebSocketException) e).getCode(), ((WebSocketException) e).getReason(), false);
            }
        } finally {
            doClose(WebSocketFrame.CloseCode.InternalServerError, "Handler terminated without closing the connection.", false);
        }
    }
    protected void handleWebsocketFrame(WebSocketFrame frame) throws IOException {
        if (frame.getOpCode() == WebSocketFrame.OpCode.Close) {
            handleCloseFrame(frame);
        } else if (frame.getOpCode() == WebSocketFrame.OpCode.Ping) {
            sendFrame(new WebSocketFrame(WebSocketFrame.OpCode.Pong, true, frame.getBinaryPayload()));
        } else if (frame.getOpCode() == WebSocketFrame.OpCode.Pong) {
            onPong(frame);
        } else if (!frame.isFin() || frame.getOpCode() == WebSocketFrame.OpCode.Continuation) {
            handleFrameFragment(frame);
        } else if (continuousOpCode != null) {
            throw new WebSocketException(WebSocketFrame.CloseCode.ProtocolError, "Continuous frame sequence not completed.");
        } else if (frame.getOpCode() == WebSocketFrame.OpCode.Text || frame.getOpCode() == WebSocketFrame.OpCode.Binary) {
            onMessage(frame);
        } else {
            throw new WebSocketException(WebSocketFrame.CloseCode.ProtocolError, "Non control or continuous frame expected.");
        }
    }
    protected void handleCloseFrame(WebSocketFrame frame) throws IOException {
        WebSocketFrame.CloseCode code = WebSocketFrame.CloseCode.NormalClosure;
        String reason = "";
        if (frame instanceof WebSocketFrame.CloseFrame) {
            code = ((WebSocketFrame.CloseFrame) frame).getCloseCode();
            reason = ((WebSocketFrame.CloseFrame) frame).getCloseReason();
        }
        if (state == State.CLOSING) {
            //Answer for my requested close
            doClose(code, reason, false);
        } else {
            //Answer close request from other endpoint and close self
            State oldState = state;
            state = State.CLOSING;
            if (oldState == State.OPEN) try {
                sendFrame(new WebSocketFrame.CloseFrame(code, reason));
            } catch (Throwable _e) {}
            doClose(code, reason, true);
        }
    }
    protected void handleFrameFragment(WebSocketFrame frame) throws IOException {
        if (frame.getOpCode() != WebSocketFrame.OpCode.Continuation) {
            //First
            if (continuousOpCode != null) {
                throw new WebSocketException(WebSocketFrame.CloseCode.ProtocolError, "Previous continuous frame sequence not completed.");
            }
            continuousOpCode = frame.getOpCode();
            continuousFrames.clear();
            continuousFrames.add(frame);
        } else if (frame.isFin()) {
            //Last
            if (continuousOpCode == null) {
                throw new WebSocketException(WebSocketFrame.CloseCode.ProtocolError, "Continuous frame sequence was not started.");
            }
            onMessage(new WebSocketFrame(continuousOpCode, continuousFrames));
            continuousOpCode = null;
            continuousFrames.clear();
        } else if (continuousOpCode == null) {
            //Unexpected
            throw new WebSocketException(WebSocketFrame.CloseCode.ProtocolError, "Continuous frame sequence was not started.");
        } else {
            //Intermediate
            continuousFrames.add(frame);
        }
    }
    public synchronized void sendFrame(WebSocketFrame frame) throws IOException {
        frame.write(out);
    }
    // --------------------------------Close-----------------------------------
    
    // deliberate closing by server, e.g. because of module reload
    public void close() {
      doClose(WebSocketFrame.CloseCode.GoingAway, "Internal closing", false);
    }
    
    protected void doClose(WebSocketFrame.CloseCode code, String reason, boolean initiatedByRemote) {
        if (state == State.CLOSED) {
            return;
        }
        if (in != null) {
            try {
                in.close();
            } catch (IOException e) {
                e.printStackTrace();
            }
        }
        if (out != null) {
            try {
                out.close();
            } catch (IOException e) {
                e.printStackTrace();
            }
        }
        state = State.CLOSED;
        onClose(code, reason, initiatedByRemote);
    }
    // --------------------------------Listener--------------------------------
    protected void onPong(WebSocketFrame pongFrame) { print("WebSocket pong"); }
    transient  IVF1<WebSocketFrame> onMessage;
void onMessage(WebSocketFrame messageFrame) { if (onMessage != null) onMessage.get(messageFrame); else onMessage_base(messageFrame); }
final void onMessage_fallback(IVF1<WebSocketFrame> _f, WebSocketFrame messageFrame) { if (_f != null) _f.get(messageFrame); else onMessage_base(messageFrame); }
void onMessage_base(WebSocketFrame messageFrame) { print("WebSocket msg: " + messageFrame.getTextPayload()); }
    transient Runnable onOpen;
void onOpen() { if (onOpen != null) onOpen.run(); else onOpen_base(); }
final void onOpen_fallback(Runnable _f) { if (_f != null) _f.run(); else onOpen_base(); }
void onOpen_base() {}
    protected void onClose(WebSocketFrame.CloseCode code, String reason, boolean initiatedByRemote) { print("WebSocket close"); onClose(); }
    transient Runnable onClose;
void onClose() { if (onClose != null) onClose.run(); else onClose_base(); }
final void onClose_fallback(Runnable _f) { if (_f != null) _f.run(); else onClose_base(); }
void onClose_base() {}
    protected void onException(IOException e) {
      printExceptionShort(e); //printStackTrace(e);
    }
    // --------------------------------Public Facade---------------------------
    public void ping(byte[] payload) throws IOException {
        sendFrame(new WebSocketFrame(WebSocketFrame.OpCode.Ping, true, payload));
    }
    public void send(byte[] payload) throws IOException {
        sendFrame(new WebSocketFrame(WebSocketFrame.OpCode.Binary, true, payload));
    }
    public void send(String payload) throws IOException {
        sendFrame(new WebSocketFrame(WebSocketFrame.OpCode.Text, true, payload));
    }
    public void close(WebSocketFrame.CloseCode code, String reason) throws IOException {
        State oldState = state;
        state = State.CLOSING;
        if (oldState == State.OPEN) {
            sendFrame(new WebSocketFrame.CloseFrame(code, reason));
        } else {
            doClose(code, reason, false);
        }
    }
    // --------------------------------Getters---------------------------------
    public NanoHTTPD.IHTTPSession getHandshakeRequest() {
        return handshakeRequest;
    }
    public NanoHTTPD.Response getHandshakeResponse() {
        return handshakeResponse;
    }
    
    // convenience methods
    String getUri() { return getHandshakeRequest().getUri(); }
    Map<String, String> getParms() { return getHandshakeRequest().getParms(); }
    Object getUserObject() { return userObject; }
    void setUserObject(Object o) { userObject = o; }
}

static interface WebSocketFactory {
  WebSocket openWebSocket(NanoHTTPD.IHTTPSession handshake);
}

static class NanoWebSocketServer extends NanoHTTPD implements WebSocketFactory {
    public static final String HEADER_UPGRADE = "upgrade";
    public static final String HEADER_UPGRADE_VALUE = "websocket";
    public static final String HEADER_CONNECTION = "connection";
    public static final String HEADER_CONNECTION_VALUE = "Upgrade";
    public static final String HEADER_WEBSOCKET_VERSION = "sec-websocket-version";
    public static final String HEADER_WEBSOCKET_VERSION_VALUE = "13";
    public static final String HEADER_WEBSOCKET_KEY = "sec-websocket-key";
    public static final String HEADER_WEBSOCKET_ACCEPT = "sec-websocket-accept";
    public static final String HEADER_WEBSOCKET_PROTOCOL = "sec-websocket-protocol";
    public final static String WEBSOCKET_KEY_MAGIC = "258EAFA5-E914-47DA-95CA-C5AB0DC85B11";
    
    WebSocketFactory webSocketFactory;
    
    public NanoWebSocketServer(int port) {
        super(port);
        webSocketFactory = null;
    }
    
    public NanoWebSocketServer(String hostname, int port) {
        super(hostname, port);
        webSocketFactory = null;
    }
    
    public NanoWebSocketServer(int port, WebSocketFactory webSocketFactory) {
        super(port);
        this.webSocketFactory = webSocketFactory;
    }
    
    public NanoWebSocketServer(String hostname, int port,WebSocketFactory webSocketFactory) {
        super(hostname, port);
        this.webSocketFactory = webSocketFactory;
    }
    
    @Override
    public Response serve_2(IHTTPSession session) {
        Map<String, String> headers = session.getHeaders();
        
        if (isWebsocketRequested(session)) {
            if (!HEADER_UPGRADE_VALUE.equalsIgnoreCase(headers.get(HEADER_UPGRADE))
                    || !isWebSocketConnectionHeader(session.getHeaders())) {
                return newFixedLengthResponse(Status.BAD_REQUEST, NanoHTTPD.MIME_PLAINTEXT, "Invalid Websocket handshake");
            }
            if (!HEADER_WEBSOCKET_VERSION_VALUE.equalsIgnoreCase(headers.get(HEADER_WEBSOCKET_VERSION))) {
                return newFixedLengthResponse(Status.BAD_REQUEST, NanoHTTPD.MIME_PLAINTEXT, "Invalid Websocket-Version " + headers.get(HEADER_WEBSOCKET_VERSION));
            }
            if (!headers.containsKey(HEADER_WEBSOCKET_KEY)) {
                return newFixedLengthResponse(Status.BAD_REQUEST, NanoHTTPD.MIME_PLAINTEXT, "Missing Websocket-Key");
            }
            WebSocket webSocket = openWebSocket(session);
            try {
                webSocket.getHandshakeResponse().addHeader(HEADER_WEBSOCKET_ACCEPT, makeAcceptKey(headers.get(HEADER_WEBSOCKET_KEY)));
            } catch (NoSuchAlgorithmException e) {
                return newFixedLengthResponse(Status.INTERNAL_ERROR, NanoHTTPD.MIME_PLAINTEXT, "The SHA-1 Algorithm required for websockets is not available on the server.");
            }
            if (headers.containsKey(HEADER_WEBSOCKET_PROTOCOL)) {
                webSocket.getHandshakeResponse().addHeader(HEADER_WEBSOCKET_PROTOCOL, headers.get(HEADER_WEBSOCKET_PROTOCOL).split(",")[0]);
            }
            return webSocket.getHandshakeResponse();
        } else {
            return super.serve_2(session);
        }
    }
    
    public WebSocket openWebSocket(IHTTPSession handshake) {
        if (webSocketFactory == null) {
            throw new Error("You must either override this method or supply a WebSocketFactory in the constructor");
        }
        return webSocketFactory.openWebSocket(handshake);
    }
    
    protected boolean isWebsocketRequested(IHTTPSession session) {
        Map<String, String> headers = session.getHeaders();
        String upgrade = headers.get(HEADER_UPGRADE);
        boolean isCorrectConnection = isWebSocketConnectionHeader(headers);
        boolean isUpgrade = HEADER_UPGRADE_VALUE.equalsIgnoreCase(upgrade);
        return (isUpgrade && isCorrectConnection);
    }
    
    private boolean isWebSocketConnectionHeader(Map<String, String> headers) {
        String connection = headers.get(HEADER_CONNECTION);
        return (connection != null && connection.toLowerCase().contains(HEADER_CONNECTION_VALUE.toLowerCase()));
    }
    
    public static String makeAcceptKey(String key) throws NoSuchAlgorithmException {
        MessageDigest md = MessageDigest.getInstance("SHA-1");
        String text = key + WEBSOCKET_KEY_MAGIC;
        md.update(text.getBytes(), 0, text.length());
        byte[] sha1hash = md.digest();
        return base64encode(sha1hash);
    }
}
interface ChangeTriggerable {
  public void change();
}
static interface IFieldsToList {
  Object[] _fieldsToList();
}
interface ISleeper_v2 {
  default Sleeping doLater(long targetTime, Runnable r) {
    return doLater(sysTimeToTimestamp(targetTime), r);
  }
  
  Sleeping doLater(Timestamp targetTime, Runnable r);
  
  public default Sleeping doAfter(double seconds, Runnable r) {
    return doLater(tsNow().plusSeconds(seconds), r);
  }
}
interface IDoublePt {
  public double x_double();
  public double y_double();
}
static interface IVar<A> extends IF0<A> {
  void set(A a);
  A get();
  
  // reified type of value (if available)
  default Class<A> getType() { return null; }
  
  default IF0<A> getter() { return () -> get(); }
  default IVF1<A> setter() { return __1 -> set(__1); }
  
  
  default boolean has() { return get() != null; }
  default void clear() { set(null); }
  
}
abstract static class DynPrintLogAndEnabled extends DynPrintLog {
  
public JComponent visualize() { return dm_visualizeWithEnabled(super.visualize()); }


volatile boolean enabled = true;
transient JPanel buttons;
transient SingleComponentPanel scpStretcherControl;

JComponent visualizeWithoutEnabled() { return super.visualize(); }
  
JComponent dm_visualizeWithEnabled(JComponent main) {
  return centerAndSouthWithMargins(main, wrapControlArea());
}

JComponent wrapControlArea() {
  return makeControlArea();
}

JPanel makeControlArea() {
  if (scpStretcherControl == null)
    scpStretcherControl = singleComponentPanel();
  var cb = makeEnabledCheckBox();
  buttons = jrightalignedline(cb);
  return centerAndEastWithMargin(scpStretcherControl, buttons);
}

static JCheckBox makeEnabledCheckBox() {
  return dm_fieldCheckBox("enabled");
}
  
void setEnabled(boolean b) { setField("enabled" , b); }

final void addControls(Component... components){ addToControlArea(components); }
void addToControlArea(Component... components) {
  addComponentsFirst(buttons, components);
}

final void addControl(Component component){ addButton(component); }
void addButton(Component component) {
  addComponentsFirst(buttons, component);
}

void addControl(Swingable component) {
  addComponentsFirst(buttons, wrap(component));
}

void setMainControl(JComponent control) {
  scpSet(scpStretcherControl, control);
}
}



static 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; }
 int interval = 50; // larger interval helps show less duplicate events (https://stackoverflow.com/questions/16777869/java-7-watchservice-ignoring-multiple-occurrences-of-the-same-event/34818620#34818620)
  int sleepSeconds = 60; // any drawback to this being very high? not sure
  
  WatchService watchService;
  MultiMap<WatchKey, IVF1<File>> listeners = new MultiMap();
  Thread pollThread;
  volatile boolean closed = false;
  
  FileWatchService() { try {
    watchService = FileSystems.getDefault().newWatchService();
  } catch (Exception __e) { throw rethrow(__e); } }
  
  public void close() { closed = true; { cleanUp(watchService); watchService = null; } }
  
  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); } }
  
  void addNonRecursiveListener(File path, IVF1<File> listener) {
    addListenerImpl(path, listener, jdk_watchService_allEventKinds());
  }
  
  void addRecursiveListener(File path, IVF1<File> listener) {
    Set<File> listeningTo = synchroSet();
    IVF1<File> listener2 = new IVF1<File>() {
      public void get(File f) {
        // TODO: remove listeners on deleted directory
        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 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);
              //print("WatchService Changed: " + full + ", " + event.kind());
            } catch (Throwable __e) { pcallFail(__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 interface WidthAndHeight {
  default int w(){ return getWidth(); }
default int width(){ return getWidth(); }
int getWidth();
  default int h(){ return getHeight(); }
default int height(){ return getHeight(); }
int getHeight();
  
  public default Rect bounds() { return rect(0, 0, getWidth(), getHeight()); }
  
  default int area() { return toInt(areaAsLong()); }
  default long areaAsLong() { return longMul(w(), h()); }
}


static class CloseablesHolder extends Meta implements AutoCloseable, IResourceHolder {
  LinkedHashSet<AutoCloseable> closeables = new LinkedHashSet();
  WeakReference<Thread> createdInThread = weakRef(currentThread());
  
  public synchronized <A extends AutoCloseable> void addAll(Iterable<A> l) {
    for (var a : unnullForIteration(l)) add(a);
  }
  
  public synchronized <A extends AutoCloseable> A add(A a) {
    if (a != null)
      closeables.add(a);
    return a;
  }
  
  // remove from list, don't close
  final  <A extends AutoCloseable> A takeOut(A a){ return remove(a); }
synchronized <A extends AutoCloseable> A remove(A a) {
    closeables.remove(a);
    return a;
  }
  
  // close and remove
  synchronized <A extends AutoCloseable> A close(A a) {
    if (a == null) return a;
    closeables.remove(a);
    main.close(a);
    return a;
  }
  
  public void close() { try {
    for (AutoCloseable c : reversed(takeAll()))
      main.close(c);
  } catch (Exception __e) { throw rethrow(__e); } }
  
  final public  void clear(){ forget(); }
public synchronized void forget() {
    closeables.clear();
  }
  
  public synchronized Collection<AutoCloseable> takeAll() {
    return cloneAndClear(closeables);
  }
}
abstract static class DynPrintLog extends DynModule {
  transient JFastLogView_noWrap printLogView;
  transient Lock updatePrintLog_lock = lock();
  transient StringBuffer actualPrintLog;
  transient int printLogUpdateInterval = 500;
  transient JComponent printLogPanel;
  
  public JComponent visualize() { return makePrintLogPanel(); }
  
  JComponent makePrintLogPanel() {
    JComponent section = printLogPanel = jSection("Log",
      jscroll_copyBackground(printLogView = jFastLogView_noWrap(getPrintLog())));
    componentPopupMenuItem(section, "Clear", new Runnable() {  public void run() { try {   AutoCloseable __3 = enter(); try {  dm_clearModulePrintLog(); 
} finally { _close(__3); }} catch (Exception __e) { throw rethrow(__e); } }  public String toString() { return "temp enter();  dm_clearModulePrintLog();"; }});
    return awtEvery(section, printLogUpdateInterval, new Runnable() {  public void run() { try {  updatePrintLog(); 
} catch (Exception __e) { throw rethrow(__e); } }  public String toString() { return "updatePrintLog();"; }});
  }
  
  void updatePrintLog() { swing(() -> { 
    // TODO: optimize
    Lock __0 = updatePrintLog_lock; lock(__0); try {
    JFastLogView_noWrap _view = printLogView;
    if (_view == null) return;
    if (_view.setText(getPrintLog())) {
      // Still trying to reliably scroll down
      scrollAllTheWayDown(_view);
      awtLater(100, new Runnable() {  public void run() { try {  scrollAllTheWayDown(_view) ;
} catch (Exception __e) { throw rethrow(__e); } }  public String toString() { return "scrollAllTheWayDown(_view)"; }});
    }
  } finally { unlock(__0); } }); }
  
  JFastLogView_noWrap myPrintLogComponent() { return printLogView; }
  
  void enableWordWrap() { // TODO
  }
  
  String getPrintLog() {
    if (actualPrintLog == null) {
      if (printToModule())
        actualPrintLog = _printLog;
      else
        actualPrintLog = liveLocalPrintLog_realMC(this);
    }
    return str(actualPrintLog);
  }
}
static interface IHasGlobalID {
  public GlobalID globalID();
}
static interface IMultiSet<A> extends IntSize {
  // returns new count
  int add(A key);
  
  /*void addAll(Iterable<A> c) {
    if (c != null) for (A a : c) add(a);
  }

  void addAll(MultiSet<A> ms) {
    for (A a : ms.keySet()) add(a, ms.get(a));
  }*/
  
  //int add(A key, int count);

  //void put(A key, int count);

  int get(A key);
  //bool contains(A key);

  //void remove(A key);

  /*List<A> topTen();
  
  synchronized List<A> getTopTen() { ret getTopTen(10); }
  synchronized List<A> getTopTen(int maxSize) {
    List<A> list = getSortedListDescending();
    return list.size() > maxSize ? list.subList(0, maxSize) : list;
  }
  
  synchronized L<A> highestFirst() {
    ret getSortedListDescending();
  }

  synchronized L<A> lowestFirst() {
    ret reversedList(getSortedListDescending());
  }

  synchronized L<A> getSortedListDescending() {
    List<A> list = new ArrayList<A>(map.keySet());
    Collections.sort(list, new Comparator<A>() {
      public int compare(A a, A b) {
        return map.get(b).compareTo(map.get(a));
      }
    });
    ret list;
  }

  synchronized int getNumberOfUniqueElements() {
    return map.size();
  }
  
  synchronized int uniqueSize() {
    ret map.size();
  }

  synchronized Set<A> asSet() {
    return map.keySet();
  }

  synchronized NavigableSet<A> navigableSet() {
    return navigableKeys((NavigableMap) map);
  }

  synchronized A getMostPopularEntry() {
    int max = 0;
    A a = null;
    for (Map.Entry<A,Integer> entry : map.entrySet()) {
      if (entry.getValue() > max) {
        max = entry.getValue();
        a = entry.getKey();
      }
    }
    return a;
  }

  synchronized void removeAll(A key) {
    size -= get(key);
    map.remove(key);
  }

  synchronized int size() {
    ret size;
  }

  synchronized MultiSet<A> mergeWith(MultiSet<A> set) {
    MultiSet<A> result = new MultiSet<A>();
    for (A a : set.asSet()) {
      result.add(a, set.get(a));
    }
    return result;
  }
  
  synchronized boolean isEmpty() {
    return map.isEmpty();
  }
  
  synchronized public String toString() { // hmm. sync this?
    return str(map);
  }
  
  synchronized void clear() {
    map.clear();
    size = 0;
  }
  
  synchronized Map<A, Int> asMap() {
    ret cloneMap(map);
  }*/
  
  Set<A> keySet();
}
abstract static class Sleeping implements AutoCloseable , IFieldsToList{
  Timestamp targetTime;
  Runnable action;
  Sleeping() {}
  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}; }

  long remainingMS() { return targetTime.minus(tsNow()); }
}
// uses hash sets as inner sets unless subclassed
// uses a hash map as the outer map by default
static class MultiSetMap<A, B>implements IMultiMap<A, B> {
  Map<A, Set<B>> data = new HashMap<A, Set<B>>();
  int size; // number of values
  
  MultiSetMap() {}
  MultiSetMap(boolean useTreeMap) { if (useTreeMap) data = new TreeMap(); }
  MultiSetMap(MultiSetMap<A, B> map) { putAll(map); }
  MultiSetMap(Map<A, Set<B>> data) {
  this.data = data;}

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

  boolean add(A key, B value) { return put(key, value); }

  void addAll(A key, Collection<B> values) { synchronized(data) {
    putAll(key, values);
  }}
  
  void addAllIfNotThere(A key, Collection<B> values) { synchronized(data) {
    for (B value : values)
      setPut(key, value);
  }}
  
  void setPut(A key, B value) { synchronized(data) {
    if (!containsPair(key, value))
      put(key, value);
  }}
  
  final boolean contains(A key, B value){ return containsPair(key, value); }
boolean containsPair(A key, B value) { synchronized(data) {
    return get(key).contains(value);
  }}
  
  void putAll(A key, Collection<B> values) { synchronized(data) {
    for (B value : values)
      put(key, value);
  }}

  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;
  }}
  
  List<B> getAndClear(A key) { synchronized(data) {
    List<B> l = cloneList(data.get(key));
    remove(key);
    return l;
  }}

  // return null if empty
  Set<B> getOpt(A key) { synchronized(data) {
    return data.get(key);
  }}

  // returns actual mutable live set
  // creates the set if not there
  Set<B> getActual(A key) { synchronized(data) {
    Set<B> set = data.get(key);
    if (set == null)
      data.put(key, set = _makeEmptySet());
    return set;
  }}
 
  // TODO: this looks unnecessary
  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();
  }}

  void remove(A key) { synchronized(data) {
    size -= l(data.get(key));
    data.remove(key);
  }}

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

  void clear() { synchronized(data) {
    data.clear();
    size = 0;
  }}

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

  B getFirst(A key) { synchronized(data) {
    return first(get(key));
  }}
  
  void addAll(MultiSetMap<A, B> map) { putAll(map); }
  
  void putAll(MultiSetMap<A, B> map) { synchronized(data) {
    for (A key : map.keySet())
      putAll(key, map.get(key));
  }}
  
  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); }}
  
  // full size
  public int size() { synchronized(data) {
    return size;
  }}
  
  // count values for key
  int getSize(A key) { return l(data.get(key)); }
  int count(A key) { return getSize(key); }
  
  // expensive operation
  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;
  }}
  
  // expensive operation
  A keyForValue(B b) { synchronized(data) {
    for (A key : data.keySet())
      if (data.get(key).contains(b))
        return key;
    return null;
  }}
  
  Map<A, Set<B>> asMap() { synchronized(data) {
    return cloneMap(data);
  }}
  
  public boolean isEmpty() { synchronized(data) { return data.isEmpty(); }}
  
  // override in subclasses
  Set<B> _makeEmptySet() {
    return new HashSet();
  }
  
  Collection<Set<B>> allLists() {
    synchronized(data) {
      return new HashSet(data.values());
    }
  }
  
  List<B> allValues() {
    return concatLists(values(data));
  }
  
  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;
  }}
  
  Object mutex() { return data; }
  
  public String toString() { return "mm" + str(data); }
  
  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()));
  }}
  
  A firstKey() { synchronized(data) { return main.firstKey(data); }}
  A lastKey() { synchronized(data) { return (A) ((NavigableMap) data).lastKey(); }}
  
  A higherKey(Object a) { synchronized(data) { return (A) ((NavigableMap) data).higherKey(a); }}
}
static class MultiSleeper implements ISleeper_v2, AutoCloseable {
  MultiSetMap<Timestamp, Runnable> entries = treeMultiSetMap();
  RestartableCountdown countdown = new RestartableCountdown();
  
  private void check() {
    var time = nextWakeUpTime();
    var action = firstValue(entries);
    countdown.setTargetTime(time == null ? 0 : time.sysTime(), new Runnable() {  public void run() { try { 
      Set<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 "Set<Runnable> toCall;\r\n      synchronized(MultiSleeper.this) {\r\n        toCal..."; }});
  }
  
  private synchronized void removeEntry(Timestamp targetTime, Runnable action) {
    entries.remove(targetTime, action);
  }
  
  // API
  
  synchronized 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); } }
    };
  }
  
  public void close() { try {
    { cleanUp(countdown); countdown = null; }
  } catch (Exception __e) { throw rethrow(__e); } }
}
static class Timestamp implements Comparable<Timestamp> , IFieldsToList{
  long date;
  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}; }

  Timestamp() { date = now(); }
  Timestamp(Date date) { if (date != null) this.date = date.getTime(); }
  
  final long toLong(){ return unixDate(); }
long unixDate() { return date; }
  long unixSeconds() { return unixDate()/1000; }
  
  public String toString() { return formatLocalDateWithSeconds(date); }
  
  // Hmm. Should Timestamp(0) be equal to null? Question, questions...
  public int compareTo(Timestamp t) {
    return t == null ? 1 : cmp(date, t.date);
  }
  
  Timestamp plus(Seconds seconds) {
    return plus(seconds == null ? null : seconds.getDouble());
  }
  
  final Timestamp plusSeconds(double seconds){ return plus(seconds); }
Timestamp plus(double seconds) {
    return new Timestamp(date+toMS(seconds));
  }
  
  // returns milliseconds
  long minus(Timestamp ts) {
    return unixDate()-ts.unixDate();
  }
  
  long sysTime() {
    return clockTimeToSystemTime(date);
  }
  
  Duration minusAsDuration(Timestamp ts) {
    return Duration.ofMillis(minus(ts));
  }
}


static class RestartableCountdown implements AutoCloseable {
  java.util.Timer timer;
  long targetTime; // in sys time

  
  long /*firings,*/ totalSleepTime; // stats
  
  
  synchronized void setTargetTime(long targetTime, Runnable action) {
    if (targetTime <= 0)
      stop();
    else if (targetTime != this.targetTime) {
      start(targetTime-sysNow(), action);
      this.targetTime = targetTime;
    }
  }
  
  // stops the countdown and restarts it
  synchronized 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;
    }
  }
  
  void start(double delaySeconds, Object action) {
    start(toMS(delaySeconds), action);
  }
  
  synchronized void stop() {
    cancelTimer(timer);
    timer = null;
    targetTime = 0;
  }
  
  public void close() { stop(); }
}
static class JFastLogView_noWrap extends JComponent implements Scrollable {
  List<String> lines = syncList();
  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) {
    //if (verbose) _print("JFastLogView_noWrap painting");
    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));
    }
    //printVars(+start, +end);
    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;
    }
    //if (verbose) _print("JFastLogView_noWrap painted");
  }
  
  public Dimension getPreferredSize() {
    FontMetrics fm = componentFontMetrics(this);
    if (fm == null) return new Dimension(50, 50); // not renderable yet
    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))); // TODO: just count chars
    }
    return new Dimension(w, fh*l(lines));
  }
  
  JFastLogView_noWrap() {}
  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();"; }});
  }
  
  // API
  
  // returns true if changed
  boolean setLines(Collection<String> lines) {
    List<String> newList = asSyncList(lines);
    if (eq(this.lines, newList)) return false;
    this.lines = newList;
    _revalidate(this);
    return true;
  }
  
  // returns true if changed
  boolean setText(String text) {
    endsWithNewLine = endsWithNewLine(text);
    return setLines(lines(text));
  }
  
  void append(String text) {
    if (nempty(text)) setText(getText() + text);
  }
  
  String getText() {
    return lines_rtrimIf(!endsWithNewLine, cloneList(lines));
  }
  
  void copyFullText() {
    copyTextToClipboard(getText());
  }
}
static class Seconds implements Comparable<Seconds> , IFieldsToList{
  double seconds;
  Seconds() {}
  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 double get(){ return seconds(); }
final double getDouble(){ return seconds(); }
double seconds() { return seconds; }
  
  public String toString() { return formatDouble(seconds, 3) + " s"; }
  
  public int compareTo(Seconds s) {
    return cmp(seconds, s.seconds);
  }
  
  Seconds div(double x) { return new Seconds(get()/x); }
  Seconds minus(Seconds x) { return new Seconds(get()-x.get()); }
}
static abstract class DynModule extends DynamicObject implements Enterable, ChangeTriggerable
 {
  // we really shouldn't have used up these variable names
  // (subclasses can't overload them due to how the persistence works)
  String name, toolTip; // module name, module tool tip in task bar
  
  PersistableThrowable _error;
  Map<String, Collection<String>> mechLists;
  Map<String, Boolean> _persistenceInfo;
  
  transient Object _host; // pointer to this module's stem
  
  transient Map<Object, IVF1> timers = newWeakHashMap(); // all kinds of resources actually; value is closer helper
  transient Set<AutoCloseable> _resources = synchroHashSet();
  transient Lock lock; // set by stem
  transient boolean persistOnChangedField = true;
  transient int changeCount;
  transient Object changeCountSync = new Object();
  transient List onChange;
  transient List onTransientChange;
  transient boolean verboseTimers = false;
  transient ReliableSingleThread rstUpdate;
  transient Set<String> componentFieldsToKeep;
  
  // TODO: use DynamicObject for this
  transient Map<String, Object> transientGeneralMap = synchroHashMap();
  
  transient Q q; // module command queue
  transient List onFieldChange; // also for non-persistent fields. L<voidfunc(S field)>
  transient boolean _hasPreviousBounds = false;
  transient StringBuffer _printLog = new StringBuffer();
  transient boolean deleted = false;
  
  DynModule() {
    if (useErrorHandling())
      dm_initErrorHandling();
      
    // TODO: DynModule is now shared between modules, so not good
    setMainDesktopPane((JDesktopPane) getCreatorOpt("desktop"));
  }
  
  boolean useErrorHandling() { return true; }
  
  boolean isVisible() { return isTrue(getOpt(_host, "visible")); }
  
  String moduleName() { return name; }
  
  void setModuleName(String name) {
    String oldName = this.name;
    if (!eq(name, oldName)) {
      setField("name", name);
      possiblyInternalFrameTitle(vis(), name);
      vmBus_send("moduleNameChange", this, oldName, name);
    }
  }
  
  void setModuleToolTip(String toolTip) {
    this.toolTip = toolTip;
  }
  
  JComponent vis() {
    return (JComponent) getOpt(_host, "vis");
  }
  
  <A extends AutoCloseable> A ownResource(A a) {
    if (a != null)
      _resources.add(a);
    return a;
  }
  
  <A> A ownTimer(A timer) {
    if (timer instanceof AutoCloseable)
      ownResource((AutoCloseable) timer);
    else
      ownTimer(timer, __10 -> cancelTimerOrInterruptThread(__10));
    return timer;
  }
  
  void ownTimer(Object timer, IVF1 closerHelper) {
    timers.put(timer, closerHelper);
  }
  
  void singleTimer(java.util.Timer timer) {
    stopAllTimers();
    ownTimer(timer);
  }
  
  void stopAllTimers() {
    for (AutoCloseable resource : getAndClearList(_resources)) {
      if (verboseTimers)
        print("Releasing resource: " + resource);
      try { resource.close(); } catch (Throwable __e) { pcallFail(__e); }
    }
      
    for (Map.Entry<? extends Object, ? extends IVF1> __0 : _entrySet( getAndClearMap(timers))) { Object timer = __0.getKey(); IVF1 closerHelper = __0.getValue(); 
      if (verboseTimers)
        print("Stopping timer: " + closerHelper + " / " + timer);
      pcallF(closerHelper, timer);
    }
  }
  
  boolean isDeleted() { return deleted; }
  boolean deleted() { return deleted; }
  
  void cleanMeUp_dynModule() {
    deleted = true;
    { cleanUp(q); q = null; }
    stopAllTimers();
  }
  
  void persistMe() {
    synchronized(changeCountSync) { ++changeCount; }
    pcallFAll(onChange); callOpt(_host, "_change");
    updateMe();
  }
  
  void fireChangeWithoutPersisting() {
    pcallFAll(onChange);
  }
  
  void fireTransientChange() {
    pcallFAll(onTransientChange);
  }
  
  final void _change() { persistMe(); }
  final public void change() { persistMe(); }
  
  void updateMe() {
    rstUpdate().trigger();
  }
  
  void changeAndUpdate() { _change(); updateMe(); }
  
  boolean setField_noPersist(String name, Object value) {
    return setField(name, value, true);
  }
  
  boolean _setField(String name, Object value) {
    return setField(name, value);
  }
  
  boolean setField(String name, Object value) { return setField(name, value, false); }
boolean setField(String name, Object value, boolean noPersist) {
     AutoCloseable __6 = enter(); try {
    try { // some really weird classes fail on equals() (BCEL JavaClass, I'm looking at you)
      if (eq(get(this, name), value)) return false;
    } catch (Throwable __e) { pcallFail(__e); }
    return setField_noCheck(name, value, noPersist);
  } finally { _close(__6); }}
    
  // always set even if equal
  boolean setField_noCheck(String name, Object value) { return setField_noCheck(name, value, false); }
boolean setField_noCheck(String name, Object value, boolean noPersist) {  AutoCloseable __7 = enter(); try {
    //set(this, name, value); 
    setOpt(this, name, value); // XXX allow virtual fields
    pcallFAll(onFieldChange, name);
    
    // XXX - new check for transient field
    if (!noPersist && dm_isPersistentField(me(), name))
      _change();
    return true;
  } finally { _close(__7); }}
  
  <A> A setFieldAndReturn(String name, A value) {
    setField(name, value);
    return value;
  }
  
  boolean setFields(Object... params) {
    boolean change = false;
    for (int i = 0; i < l(params); i += 2)
      if (setField((String) params[i], params[i+1])) change = true;
    return change;
  }
  
  void start() {
    _hasPreviousBounds = dm_getBounds() != null;
    if (hasMethod_onTypes(this, "onTopInput", String.class))
      dm_onTopInput_q(new VF1<String>() { public void get(String s) { try {  call(module(), "onTopInput", s) ; } catch (Exception __e) { throw rethrow(__e); } }
  public String toString() { return "call(module(), 'onTopInput, s)"; }});
  }
  
  void revisualize() {
    call(dm_os(), "revisualizeModule", _host);
  }
  
  boolean useEnterShortcut() { return false; }
  
  public AutoCloseable enter() {
    AutoCloseable c = tempSetBetterThreadLocalIfNecessary_weakRef(dm_current_generic_tl(), this);
    
    /// XXX shortcut, testing now (doesn't seem to work yet)
    if (c == null && useEnterShortcut()) return null; // assume we are entered (so the rest of what we do in this function is also done)
    
    Object realMC = getMainClass(this);
    if (printToModule())
      c = combineAutoCloseables(c, tempInterceptPrintIfNotIntercepted(_printToModuleInterceptor()));
    if (realMC != mc()) {
      if (printToModule())
        c = combineAutoCloseables(c, (AutoCloseable) callOpt(realMC, "tempInterceptPrintIfNotIntercepted", _printToModuleInterceptor()));
      else
        c = combineAutoCloseables(c, tempInterceptPrintIfNotIntercepted(new F1<String, Boolean>() { public Boolean get(String s) { try { 
          { call(realMC, "print", s); return false; }
         } catch (Exception __e) { throw rethrow(__e); } }
  public String toString() { return "ret false with call(realMC, 'print, s);"; }}));
      c = combineAutoCloseables(c, tempSetTL(realMC_tl(), realMC));
    }
    return c;
  }
  
  F1<String, Boolean> _printToModuleInterceptor() {
    return new F1<String, Boolean>() { public Boolean get(String s) { try { 
      if (print_preprocess != null) s = (String) callF(print_preprocess, s);
      s = fixNewLines(s);
      Appendable loc = _printLog;
      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);
      return false;
     } catch (Exception __e) { throw rethrow(__e); } }
  public String toString() { return "if (print_preprocess != null) s = (S) callF(print_preprocess, s);\r\n      s = ..."; }};
  }
  
  boolean printToModule() { return true; } // on by default now
  
  AutoCloseable enterAndLock() {
    return combineAutoCloseables(enter(), tempLock(lock));
  }
  
  boolean setError(Throwable e) {
    setField("_error" , persistableThrowable(e));
    return true;
  }
  
  void clearError() {
    setField("_error" , null);
  }
  
  
  
  
    void onChange(Runnable r) {
      Lock __2 = lock; lock(__2); try {
      if (onChange == null) onChange = synchroList();
      addIfNotThere(onChange, r);
    } finally { unlock(__2); } }
  
    public void removeChangeListener(Runnable r) {
      remove(onChange, r);
    }
  
  
  void onFieldChange(VF1<String> r) {
    Lock __3 = lock; lock(__3); try {
    if (onFieldChange == null) onFieldChange = synchroList();
    addIfNotThere(onFieldChange, r);
  } finally { unlock(__3); } }
  
  void removeFieldChangeListener(VF1<String> r) {
    remove(onFieldChange, r);
  }
  
  
    void onChangeAndNow(Runnable r) {
      onChange(r);
      callF(r);
    }
  
  
  // forward to main class
  void onChangeAndNow(JComponent c, Object r) {
    onUpdateAndNow(c, r);
  }
  
  void onChangeAndNow(List<? extends JComponent> l, Object r) {
    main.onChangeAndNow(l, r);
  }
  
  void onChangeAndNow(JTextComponent c, IVF1<String> r) {
    onUpdateAndNow(c, r);
  }
  
  /*static*/ <A extends JComponent> A onChange(A tc, Object r) {
    onUpdate(tc, r);
    return tc;
  }

  void update() {}
  
  void unvisualize() {
    zeroAllFieldsOfTypeExcept(this, Component.class, componentFieldsToKeep);
  }
  
  // return L<AbstractAction> (legacy)
  // or litobjectarray(text, Runnable, text, Runnable, ...)
  Object menuItems() {
    return null;
  }
  
  void enhanceFrame(Container f) {
    
    Object items = menuItems();
    if (items instanceof Object[])
      items = paramsToAbstractActions((Object[]) items);
    internalFramePopupMenuFromActions_threaded(f, (List) items);
    
    
    String switchableFields =  (String) (callOpt(this, "switchableFields"));
    Set<String> set = asLinkedHashSet(splitAtSpace(switchableFields));
    Matches m = new Matches();
    for (String field : allFields(getClass()))
      if (startsWith(field, "_switchableField_", m))
        set.add(m.rest());
    for (String field : set) {
      Class type = fieldType(this, field);
      if (eq(boolean.class, type))
        dm_boolFieldMenuItem(f, field);
      else if (eq(int.class, type))
        dm_intFieldMenuItem(f, field);
      else if (eq(long.class, type))
        dm_longFieldMenuItem(f, field);
      else if (eq(double.class, type))
        dm_doubleFieldMenuItem(f, field);
      else if (eq(float.class, type))
        dm_floatFieldMenuItem(f, field);
      else if (eq(String.class, type))
        dm_stringFieldMenuItem(f, field);
      else if (eq(File.class, type))
        dm_fileFieldMenuItem(f, field);
    }
    
  }
  
  // assume this is called in start(), so no locking
  ReliableSingleThread rstUpdate() {
    if (rstUpdate == null) rstUpdate = dm_rst(this, new Runnable() {  public void run() { try {   AutoCloseable __8 = enter(); try { update(); 
} finally { _close(__8); }} catch (Exception __e) { throw rethrow(__e); } }  public String toString() { return "temp enter(); update();"; }});
    return rstUpdate;
  }
  
  Q q() {  AutoCloseable __9 = enter(); try {
    if (q == null) {
      Lock __4 = lock; lock(__4); try {
      if (q == null) q = dm_startQ();
    } finally { unlock(__4); } }
    return q;
  } finally { _close(__9); }}
  
  <A> A withUpdate(A a) {
    rstUpdate().trigger();
    return a;
  }
  
  DynModule module() { return this; }
  DynModule me() { return this; }
  
  JComponent visualize() {
    return dm_noVisualisation();
  }
  
  String programTitle_cache;
  String programTitle() {
    if (programTitle_cache == null)
      programTitle_cache = snippetTitle(programID(mainClass(this)));
    return programTitle_cache;
  }
  
  // field must be non-transient
  void doPersist(String field) {
    _persistenceInfo = mapMinus(_persistenceInfo, field);
  }
  
  void dontPersist(String field) {
    _persistenceInfo = mapPlus(_persistenceInfo, "field" , false);
  }
  
  Appendable _actualPrintLog() { return printToModule() ? _printLog : print_log; }
  
  Object getHost() { return _host; }
  
  
<A> boolean addAndChange(Collection<A> cl, A a) {
  if (cl == null || !cl.add(a)) return false;
  change();
  return true;
}

<A> void clearAndChange(Collection<A> cl) {
  if (cl == null) return;
  cl.clear();
  change();
}


} // end of DynModule

static void _registerTimer(java.util.Timer timer) {
  _registerTimer_original(timer);
  var mod = dm_currentModule();
  { if (mod != null) mod.ownTimer(timer); }
}


/*
TODO: thread {} should enter the module
svoid _onLoad_moduleThreadInfo {
  _threadInfo_addMakerAndRetriever(
    voidfunc(Map map) { mapPut(map, dm_current := dm_currentModule()) },
    voidfunc(Map map) { dm_enter((S) map.get('dm_current)) });
}
*/

static class GlobalID implements Comparable<GlobalID> {
  // We need 76 bits for 26^16 IDs
  long a; // lower 64 bits
  int b;  // 76-64=12 higher bits; could be short. change to short when unstructure() is smarter
  
  GlobalID() {}
  GlobalID(String id) {
    assertGlobalID(id);
    BigInteger value = bigint(0);
    for (int i = 0; i < l(id); i++)
      value = plus(mul(value, 26), charDiff(id.charAt(i), 'a'));
      
    
    a = value.longValue();
    value = value.shiftRight(64);
    b = value.shortValue();
  }
  
  public String toString() {
    BigInteger value = bigint(b);
    value = value.shiftLeft(32);
    value = plus(value, (a >> 32) & 0xFFFFFFFFL);
    value = value.shiftLeft(32);
    value = plus(value, a & 0xFFFFFFFFL);
    
    
    
    return bigintToGlobalID(value);
  }
  
  public boolean equals(Object o) {
    if (!(o instanceof GlobalID)) return false;
    return ((GlobalID) o).a == a && ((GlobalID) o).b == b;
  }
  
  public int hashCode() {
    return (int) a;
  }
  
  // matches ID's lexical ordering
  public int compareTo(GlobalID id) {
    int diff = b-id.b;
    return diff != 0 ? diff : Long.compareUnsigned(a, id.a);
  }
}


static class Q implements AutoCloseable {
  String name = "Unnamed Queue";
  List<Runnable> q = synchroLinkedList();
  ReliableSingleThread rst = new ReliableSingleThread(new Runnable() {  public void run() { try {  _run() ;
} catch (Exception __e) { throw rethrow(__e); } }  public String toString() { return "_run()"; }});
   final public boolean getRetired(){ return retired(); }
public boolean retired() { return retired; }
volatile boolean retired = false;
   final public Runnable getCurrentJob(){ return currentJob(); }
public Runnable currentJob() { return currentJob; }
volatile Runnable currentJob;
  AtomicLong jobsDone = new AtomicLong();
  
  Q() {}
  Q(String name) {
  this.name = name;}
  
  void add(Runnable r) {
    assertNotRetired();
    q.add(r);
    _trigger();
  }
  
  void addInFront(Runnable r) {
    assertNotRetired();
    q.add(0, r);
    _trigger();
  }
  
  void _trigger() {
    rst.name = name;
    rst.go();
  }
  
  void add(Object r) {
    add(toRunnable(r));
  }
  
  void _run() {
    Runnable r;
    while (licensed() && !retired && (r = syncPopFirst(q)) != null) {
      currentJob = r;
      inc(jobsDone);
      try { r.run(); } catch (Throwable __e) { pcallFail(__e); }
      currentJob = null;
    }
    onIdle();
  }
  
  public void close() { retired = true; } // TODO: interrupt thread
  void done() {} // legacy function
  
  boolean isEmpty() { return q.isEmpty(); }
  int size() { return q.size(); }
  
  Object mutex() { return q; } // clients can synchronize on this
  List<Runnable> snapshot() { return cloneList(q); }
  
  // override this
  void onIdle() {}
  
  boolean busy() { return currentJob != null; }
  
  void assertNotRetired() {
    assertFalse("Queue is retired", retired());
  }
  
  boolean hasThread() { return rst.hasThread(); }
  
  long nJobsDone() { return jobsDone.get(); }
  
  public String toString() {
    return (retired ? "Retired " : "") + "Q " + systemHashCodeHex(this)
      + " (" + (isEmpty() ? "empty" : nEntries(size()) + ", current job: " + currentJob) + ")";
  }
}
interface Enterable {
  AutoCloseable enter();
}
interface IHasChangeListeners {
  IHasChangeListeners onChange(Runnable r);
  IHasChangeListeners removeChangeListener(Runnable r);
  
  default IHasChangeListeners onChangeAndNow(Runnable l) {
    onChange(l);
    callF(l);
    return this;
  }
}
static class ReliableSingleThread implements Runnable {
boolean _isTransient() { return true; }
  Object runnable; // usually a Runnable. is allowed to call trigger() itself
  String name = "Single Thread";
  boolean cancelBeforeTrigger = false; // always cancel running thread and wait for it to end before starting new operation
  boolean waitBetweenCancelAndTrigger = false; // make sure the old thread is actually ended
  F0<AutoCloseable> enter; // optional ownership marker, e.g. for DynModules
  int cancelTimeOut = 10000;
  
  boolean trigger = false;
  Thread thread;
  WeakReference<Thread> threadBeingCancelled;
  List<Runnable> inserts = syncL();
  
  // If you want to set the action later
  ReliableSingleThread() {}
  
  // legacy
  ReliableSingleThread(Object runnable) {
  this.runnable = runnable;}
  
  ReliableSingleThread(Runnable runnable) {
  this.runnable = runnable;}
  
  void trigger() { go(); }
  synchronized 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(); }
  void get() { go(); } // so you can use the ! syntax
  
  synchronized boolean running() { return thread != null; }
  
  // use only if this is the last time you trigger this
  void triggerAndWait() {
    trigger();
    waitUntilDone();
  }
  
  void waitUntilDone() {
    while (running()) sleep(1);
  }
  
  transient Runnable preSleep;
void preSleep() { if (preSleep != null) preSleep.run(); else preSleep_base(); }
final void preSleep_fallback(Runnable _f) { if (_f != null) _f.run(); else preSleep_base(); }
void preSleep_base() {}
  
  void _run() { try {
    while (licensed()) {
      preSleep();
      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 void cancel() {
    if (thread == null) return;
    threadBeingCancelled = new WeakReference(thread);
    cancelAndInterruptThread(thread);
    thread = null;
  }
  
  void cancelAndWait() {
    Thread _thread;
    
    synchronized(this) {
      if (thread == null) return;
      _thread = thread;
      threadBeingCancelled = new WeakReference(thread);
      thread = null;
    }
    
    cancelAndInterruptThread(_thread);
  }
  
  void cancelAndTrigger() {
    cancelAndPossiblyWait();
    trigger();
  }
  
  synchronized boolean triggered() { return trigger; }
  
  void cleanMeUp() { cancel(); }
  
  ReliableSingleThread cancelBeforeTrigger() {
    cancelBeforeTrigger = true;
    return this;
  }
  
  void cancelAndPossiblyWait() {
    if (waitBetweenCancelAndTrigger)
    cancel();
      
  }
  
  // TODO: trigger technically not necessary, just notify (I guess)
  void insert(Runnable r) { inserts.add(r); trigger(); }
  
  synchronized boolean hasThread() { return thread != null; }
  
  ReliableSingleThread action(Runnable r) { runnable = r; return this; }
}


static Lock dbLock() {
  return db_mainConcepts().lock;
}

static Lock dbLock(Concepts cc) {
  return cc == null ? null : cc.lock;
}

static Lock dbLock(Concept c) {
  return dbLock(c == null ? null : c._concepts);
}


static boolean bareDBMode_on = false;

static void bareDBMode() {
  bareDBMode(null); // default autoSaveInterval
}

static void bareDBMode(Integer autoSaveInterval) {
  bareDBMode_on = true;
  conceptsAndBot(autoSaveInterval);
}


// 302 = "Moved temporarily"
static NanoHTTPD.Response serveRedirect(String url) { return serveRedirect(url, NanoHTTPD.MIME_PLAINTEXT); }
static NanoHTTPD.Response serveRedirect(String url, String contentType) {
  NanoHTTPD.IStatus status = new NanoHTTPD.IStatus() {
    public String getDescription() { return "302 Moved temporarily"; }
    public int getRequestStatus() { return 302; }
  };
  
  NanoHTTPD.Response r = NanoHTTPD.newFixedLengthResponse(
    status,
    contentType, "");
  r.addHeader("Location", url);
  return r;
}


static NanoHTTPD.Response serve403() {
  return serve403("Forbidden");
}

static NanoHTTPD.Response serve403(String msg) {
  return NanoHTTPD.newFixedLengthResponse(NanoHTTPD.Status.FORBIDDEN, NanoHTTPD.MIME_PLAINTEXT, "Code 403 - " + msg);
}







static NanoHTTPD.Response serve404() {
  return serve404("Not found");
}
static NanoHTTPD.Response serve404(String msg) {
  return NanoHTTPD.newFixedLengthResponse(NanoHTTPD.Status.NOT_FOUND, NanoHTTPD.MIME_PLAINTEXT, "Code 404 - " + msg);
}






static NanoHTTPD.Response serve500() {
  return serve500("Internal Server Error");
}

static NanoHTTPD.Response serve500(String msg) {
  return NanoHTTPD.newFixedLengthResponse(NanoHTTPD.Status.INTERNAL_ERROR, NanoHTTPD.MIME_PLAINTEXT, "Code 500 - " + msg);
}






static NanoHTTPD.Response serveFile(File file) {
  return serveFile(file, "application/octet-stream");
}

static NanoHTTPD.Response serveFile(File file, String mimeType) { try {
  return NanoHTTPD.newFixedLengthResponse(NanoHTTPD.Status.OK, mimeType, newFileInputStream(file), file.length());
} catch (Exception __e) { throw rethrow(__e); } }



static NanoHTTPD.Response serveFileWithName(File file) {
  return serveFileWithName(file, file.getName());
}

static NanoHTTPD.Response serveFileWithName(File file, String name) {
  return serveWithFileName_addName(serveFile(file), name);
}

static NanoHTTPD.Response serveWithFileName_addName(NanoHTTPD.Response r, String name) {
  r.addHeader("Content-Disposition", "inline; filename=\"" + name + "\""); // todo: encode special characters
  return r;
}

static NanoHTTPD.Response serveFileWithName(File file, String name, String mimeType) {
  return serveWithFileName_addName(serveFile(file, mimeType), name);
}


static NanoHTTPD.Response serveFile_maxCache(File file) {
  return serveFile(file, "application/octet-stream");
}

static NanoHTTPD.Response serveFile_maxCache(File file, String mimeType) { try {
  return maxCacheHeaders(NanoHTTPD.newFixedLengthResponse(NanoHTTPD.Status.OK, mimeType, new FileInputStream(file), file.length()));
} catch (Exception __e) { throw rethrow(__e); } }





static NanoHTTPD.Response serveByteArray(byte[] data, String mimeType) { try {
  return NanoHTTPD.newFixedLengthResponse(NanoHTTPD.Status.OK, mimeType, new ByteArrayInputStream(data), l(data));
} catch (Exception __e) { throw rethrow(__e); } }



static NanoHTTPD.Response serveByteArray_maxCache(byte[] data, String mimeType) { try {
  return maxCacheHeaders(serveByteArray(data, mimeType));
} catch (Exception __e) { throw rethrow(__e); } }





static NanoHTTPD.Response serveInputStream(InputStream in, String mimeType) { try {
  return NanoHTTPD.newChunkedResponse(NanoHTTPD.Status.OK, mimeType, in);
} catch (Exception __e) { throw rethrow(__e); } }



static NanoHTTPD.Response servePartialContent(String mimeType, InputStream inputStream, long length) { try {
  return NanoHTTPD.newFixedLengthResponse(NanoHTTPD.Status.PARTIAL_CONTENT,
    mimeType, inputStream, length);
} catch (Exception __e) { throw rethrow(__e); } }


static NanoHTTPD.Response serveRangeNotSatisfiable(String msg) { try {
  return NanoHTTPD.newFixedLengthResponse(NanoHTTPD.Status.RANGE_NOT_SATISFIABLE, "text/html", msg);
} catch (Exception __e) { throw rethrow(__e); } }


static List<String> myInnerClasses_list=litlist(
null, "IVarWithNotify", "Meta", "DefunctClassLoader", "IntVar", "talkToThisVM_IO", "PingSource", "IFieldIndex", "HTTPSpamBlocker1", "SimpleLiveValue", "WebRequest", "SingleComponentPanel", "DynModule", "Rect", "IWebRequest", "Pt", "AbstractLayoutManager", "BufferedImageWithMeta", "IterableIterator", "betterCIComparator_C", "RemoteDB", "MakesBufferedImage", "Concepts", "RC", "PCallPolicy", "Hasher", "CloseableIterableIterator", "PNGFile", "ExpiringMap2", "getOpt_Map", "IFieldsToList", "IResponder", "structure_Data", "ServeHttp_CookieHandler", "jsonDecode_Y", "IVar", "DynPrintLogAndEnabled", "DynEleu", "Enterable", "Matches", "ConceptWithGlobalID", "TableWithTooltips", "Dyn_FieldWatcher", "Timestamp", "Q", "ConceptFieldIndexBase", "RestartableCountdown", "TransientObject", "MultiSet", "T3", "IResourceHolder", "CloseablesHolder", "IConceptCounter", "UnsynchronizedCompactHashSet", "NanoWebSocketServer", "BetterLabel", "componentPopupMenu_Adapter", "RGBImage", "FileWatchService", "SmartTimerTask", "JSection", "IF0WithChangeListeners", "FullChange", "ConceptDelete", "GoogleUser", "MultiSleeper", "WebSocketFactory", "ReliableSingleThread", "unstructure_Handler", "IMultiMap", "Eleu3", "PtInComponent", "AutoComboBox", "ProgramScan", "WebSocketException", "ConceptFieldIndex", "F0", "F1", "F2", "RandomAccessAbstractList", "RGB", "unstructure_Receiver", "WidthAndHeightFinal", "IF0", "IHasGlobalID", "BaseXRef", "ConceptFieldIndexCI", "IF2", "IF1", "tablePopupMenu_Maker", "IVF1", "IVF2", "Domain", "Cache", "_MethodCache", "IConcept", "PingSourceCancelledException", "structure_ClassInfo", "CookieUser", "LiveValue", "HostAndPort", "DialogHandler", "proxy_InvocationHandler", "Pair", "Swingable", "HandleProxyRequest", "WebSocket", "ChangeTriggerable", "GrabbableIntPixels", "TransferableImage", "Sleeping", "IConceptIndex", "ReverseChain", "Updateable", "ConceptCreate", "Seconds", "SNIKeyManager", "MultiSetMap", "Var", "Scorer", "ITokCondition", "PopupMenuMaker", "CountingOutputStream", "AppendableChain", "ConceptChange", "CompactAbstractMap", "CompactLinkedHashSet", "FixedRateTimer", "Fail", "CRUD", "ISetter", "ScannedBot", "XRef", "IIntPred", "Chain", "CompactHashMap", "ThreadPool", "IDialogHandler", "Complex", "MultiMap", "IHasChangeListeners", "CriticalAction", "IResourceLoader", "WeakHasherMap", "Either", "JMenuScroller", "DialogIO", "SimpleCRUD", "IAutoCloseableF0", "MRUCache", "ISleeper_v2", "AlphanumComparator", "PersistableThrowable", "talkToSubBot_IO", "IDoublePt", "WidthAndHeight", "HasIndex", "Responder", "VF1", "VF2", "IMultiSet", "TableSearcher", "WithToolTip", "ConceptsChange", "TokCondition", "RightAlignedLine", "GlobalID", "Unstructurer", "findCodeTokens_Matcher", "IntSize", "tempAdd_undo", "JFastLogView_noWrap", "WebSocketFrame", "Concept", "IRGBImage", "IRef", "MyHTTPD", "TreeMultiMap", "Flag", "generalizedCIComparator_C", "ContentsIndexedList", "IContentsIndexedList2", "Producer", "WebSocketWithWebRequest", "Value", "talkTo_IO", "User", "FileBasedLock", "Symbol", "IMeta", "UpdateTrigger", "BetterThread", "NanoHTTPD", "IContentsIndexedList", "LetterLayout", "BetterThreadLocal", "Lowest", "ChangeTrigger", "WebSocketHTTPD", "StandaloneHttpProxy", "DynPrintLog", "MinimalChain", "IBest", "jLiveValueSection_class", "Android3", "Session");

static List<String> myInnerClasses() {
  return myInnerClasses_list;
}

static <A extends JComponent> A setToolTip(A c, Object toolTip) {
  return setToolTipText(c, toolTip);
}

static <A extends JComponent> A setToolTip(Object toolTip, A c) {
  return setToolTipText(c, toolTip);
}

static void setToolTip(TrayIcon trayIcon, String toolTip) {
  setTrayIconToolTip(trayIcon, toolTip);
}


static <A extends JComponent> A toolTip(A c, final Object toolTip) {
  return setToolTipText(c, toolTip);
}



static <A extends JComponent> A toolTip(Object toolTip, A c) {
  return setToolTipText(toolTip, c);
}


// binary legacy syntax
static String formatFunctionCall(String fname, Object... args) {
  return formatFunctionCall((Object) fname, args);
}
  
static String formatFunctionCall(Object fname, Object... args) {
  return fname + "(" + joinWithComma(allToString(args)) + ")";
}

static String formatFunctionCall(String fname, Iterable args) {
  return formatFunctionCall((Object) fname, args);
}

static String formatFunctionCall(Object fname, Iterable args) {
  return formatFunctionCall(fname, toObjectArray(args));
}


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

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

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

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


static void add(BitSet bs, int i) {
  bs.set(i);
}

static <A> boolean add(Collection<A> c, A a) {
  return c != null && c.add(a);
}


static void add(Container c, Component x) {
  addToContainer(c, x);
}


static long add(AtomicLong l, long b) {
  return l.addAndGet(b);
}


static <A> A _print(String s, A a) {
  return print(s, a);
}

static <A> A _print(A a) {
  return print(a);
}

static void _print() {
  print();
}


static boolean _eq(Object a, Object b) {
  return eq(a, b);
}


static String toString(Object o) {
  return strOrNull(o);
}


static String formatDouble(double d, int digits) {
  String format = digits <= 0 ? "0" : "0." + rep(digits, '#');
  return decimalFormatEnglish(format, d);
}

static String formatDouble(double d) {
  return str(d);
}




static double ratioToPercent(double x, double y) {
  return x*100/y;
}


static <A, B> List<B> getAll(Map<A, B> map, Collection<A> l) {
  return lookupAllOpt(map, l);
}

static <A, B> List<B> getAll(Collection<A> l, Map<A, B> map) {
  return lookupAllOpt(map, l);
}

static <A, B extends IF0<A>> List<A> getAll(Iterable<B> l) {
  return getVars(l);
}


static <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 String shortClassName_dropNumberPrefix(Object o) {
  return dropNumberPrefix(shortClassName(o));
}


static int boostHashCombine(int a, int b) {
  return a ^ (b + 0x9e3779b9 + (a << 6) + (a >>> 2));
  
  // OLD (changed) 2022/3/10: ret a ^ (b + 0x9e3779b9 + (a << 6) + (a >> 2));
}


static int _hashCode(Object a) {
  return a == null ? 0 : a.hashCode();
}


static NavigableMap synchroTreeMap() {
  return synchroNavigableMap(new TreeMap());
}



static boolean hasConcept(Class<? extends Concept> c, Object... params) { return hasConcept(db_mainConcepts(), c, params); }
static boolean hasConcept(Concepts cc, Class<? extends Concept> c, Object... params) {
  return findConceptWhere(cc, c, params) != null;
}


static Object load(String varName) {
  readLocally(varName);
  return get(mc(), varName);
}

static Object load(String progID, String varName) {
  readLocally(progID, varName);
  return get(mc(), varName);
}


static void clearConcepts() {
  db_mainConcepts().clearConcepts();
}

static void clearConcepts(Concepts concepts) {
  concepts.clearConcepts();
}


static Map unstructureMap(String s) {
  return (Map) unstructure(s);
}

static Map unstructureMap(String text, boolean allDynamic, Object classFinder) {
  return (Map) unstructure(text, allDynamic, classFinder);
}


static boolean exceptionMessageContains(Throwable e, String s) {
  return cic(getInnerMessage(e), s);
}


static void printShortException(Throwable e) {
  print(exceptionToStringShort(e));
}

static void printShortException(String s, Throwable e) {
  print(s, exceptionToStringShort(e));
}


static Object unstructureGZFile(File f) { return unstructureGZFile(f, null); }
static Object unstructureGZFile(File f, IF1<String, Class> classFinder) { try {
  if (!fileExists(f)) return null;
   BufferedReader reader = utf8BufferedReader(gzInputStream(f)); try {
  return unstructure_tok(javaTokC_noMLS_onReader(reader), false, classFinder);
} finally { _close(reader); }} catch (Exception __e) { throw rethrow(__e); } }


static File conceptsFile(String progID) {
  return getProgramFile(progID, conceptsFileName());
}

static File conceptsFile() {
  return conceptsFile(dbProgramID());
}

static File conceptsFile(Concepts concepts) {
  return concepts.conceptsFile();
}


static IF1 toIF1(final Object f) {
  if (f == null) return null;
  if (f instanceof IF1) return (IF1) f;
  if (isString(f)) {
    
      throw fail("callF_legacy");
    
    
  }
  return new IF1() {
    public Object get(Object a) { return callF(f, a); }
  };
}


static int done_minPrint = 10;

static long done(long startTime, String desc) {
  long time = now()-startTime;
  if (time >= done_minPrint)
    print(desc + " [" + time + " ms]");
  return time;
}

static long done(String desc, long startTime) {
  return done(startTime, desc);
}

static long done(long startTime) {
  return done(startTime, "");
}


static String n2(long l) { return formatWithThousands(l); }
static String n2(AtomicLong l) { return n2(l.get()); }
static String n2(Collection l) { return n2(l(l)); }
static String n2(Map map) { return n2(l(map)); }

static String n2_getPlural(String singular) {
  //ret singular + "s";
  return plural(singular);
}

static String n2(double l, String singular) {
  return empty(singular) ? str(l) : n2(l, singular, n2_getPlural(singular));
}

static String n2(double l, String singular, String plural) {
  if (fraction(l) == 0)
    return n2((long) l, singular, plural);
  else
    return l + " " + plural;
}

static String n2(long l, String singular, String plural) {
  return n_fancy2(l, singular, plural);
}

static String n2(long l, String singular) {
  return empty(singular) ? n2(l) : n_fancy2(l, singular, n2_getPlural(singular));
}

static String n2(Collection l, String singular) {
  return n2(l(l), singular);
}

static String n2(Collection l, String singular, String plural) {
  return n_fancy2(l, singular, plural);
}

static String n2(Map m, String singular, String plural) {
  return n_fancy2(m, singular, plural);
}

static String n2(Map m, String singular) {
  return n2(l(m), singular);
}

static String n2(long[] a, String singular) { return n2(l(a), singular); }

static String n2(Object[] a, String singular) { return n2(l(a), singular); }
static String n2(Object[] a, String singular, String plural) { return n_fancy2(a, singular, plural); }


  static String n2(MultiSet ms, String singular) { return n2(ms, singular, n2_getPlural(singular)); }
static String n2(MultiSet ms, String singular, String plural) {
    return n_fancy2(ms, singular, plural);
  }



  static String n2(IMultiMap mm, String singular) { return n2(mm, singular, n2_getPlural(singular)); }
static String n2(IMultiMap mm, String singular, String plural) {
    return n_fancy2(l(mm), singular, plural);
  }



static RemoteDB connectToDBOpt(String dbNameOrID) { try {
  return new RemoteDB(dbNameOrID);
} catch (Throwable __e) { return null; } }


static <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 String dynShortName(Object o) {
  return shortDynamicClassName(o);
}


static <A, B> Collection<B> values(Map<A, B> map) {
  return map == null ? emptyList() : map.values();
}

// convenience shortcut for values_gen
static Collection values(Object map) {
  return values((Map) map);
}


static <A, B> Collection<B> values(MultiMap<A, B> mm) {
  return mm == null ? emptyList() : concatLists(values(mm.data));
}





static Concept getConcept(long id) {
  return db_mainConcepts().getConcept(id);
}

static Concept getConcept(Concepts concepts, long id) {
  return concepts.getConcept(id);
}
 
static <A extends Concept> A getConcept(Class<A> cc, long id) {
  return getConcept(db_mainConcepts(), cc, id);
}

static <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 <A, B> A lastKey(SortedMap<A, B> map) {
  return empty(map) ? null : map.lastKey();
}


static File conceptsDir() { return conceptsDir(db_mainConcepts()); }
static File conceptsDir(Concepts cc) {
  return cc.conceptsDir();
}

static File conceptsDir(String subName) { return conceptsDir(db_mainConcepts(), subName); }
static File conceptsDir(Concepts cc, String subName) {
  return newFile(conceptsDir(cc), subName);
}


// wrapper: VF1<Runnable> or null
static void callRunnableWithWrapper(Object wrapper, Runnable r) {
  if (wrapper == null) callF(r);
  else callF(wrapper, r);
}



static List callFAll(Collection l, Object... args) {
  return callF_all(l, args);
}


static long saveGZStructureToFile(String file, Object o) {
  return saveGZStructureToFile(getProgramFile(file), o);
}
  
// returns number of uncompressed bytes written
static long saveGZStructureToFile(File file, Object o) { return saveGZStructureToFile(file, o, new structure_Data()); }
static long saveGZStructureToFile(File file, Object o, structure_Data data) { try {
  File parentFile = file.getParentFile();
  if (parentFile != null)
    parentFile.mkdirs();
  File tempFile = tempFileFor(file);
  if (tempFile.exists()) try {
    String saveName = tempFile.getPath() + ".saved." + now();
    copyFile(tempFile, new File(saveName));
  } catch (Throwable e) { printStackTrace(e); }
  
  FileOutputStream fileOutputStream = newFileOutputStream(tempFile.getPath());
  CountingOutputStream cos;
  try {
    GZIPOutputStream gos = new GZIPOutputStream(fileOutputStream);
    cos = new CountingOutputStream(gos);
    OutputStreamWriter outputStreamWriter = new OutputStreamWriter(cos, "UTF-8");
    PrintWriter printWriter = new PrintWriter(outputStreamWriter);
    structureToPrintWriter(o, printWriter, data);
    printWriter.close();
    gos.close();
    fileOutputStream.close();
  } catch (Throwable e) {
    fileOutputStream.close();
    tempFile.delete();
    throw rethrow(e);
  }
  
  if (file.exists() && !file.delete())
    throw new IOException("Can't delete " + file.getPath());

  if (!tempFile.renameTo(file))
    throw new IOException("Can't rename " + tempFile + " to " + file);
    
  return cos.getFilePointer();
} catch (Exception __e) { throw rethrow(__e); } }


static long toM(long l) {
  return (l+1024*1024-1)/(1024*1024);
}

static String toM(long l, int digits) {
  return formatDouble(toM_double(l), digits);
}


static String javaTokWordWrap(String s) {
  return javaTokWordWrap(120, s);
}

// TODO: complete trimming
static String javaTokWordWrap(int cols, String s) {
  int col = 0;
  List<String> tok = javaTok(s);
  for (int i = 0; i < l(tok); i++) {
    String t = tok.get(i);
    if (odd(i) && col >= cols && !containsNewLine(t))
      tok.set(i, t = rtrimSpaces(t) + "\n");
    int idx = t.lastIndexOf('\n');
    if (idx >= 0) col = l(t)-(idx+1);
    else col += l(t);
  }
  return join(tok);
}


static String fileName(File f) {
  return f == null ? null : f.getName();
}


static String ymd() {
  return ymd(now());
}

static String ymd(long now) {
  return year(now) + formatInt(month(now), 2) + formatInt(dayOfMonth(now), 2);
}

static String ymd(long now, TimeZone tz) {
  return year(now, tz) + formatInt(month(now, tz), 2) + formatInt(dayOfMonth(now, tz), 2);
}


static String formatInt(int i, int digits) {
  return padLeft(str(i), '0', digits);
}

static String formatInt(long l, int digits) {
  return padLeft(str(l), '0', digits);
}


static int hours() {
  return hours(java.util.Calendar.getInstance());
}

static int hours(java.util.Calendar c) {
  return c.get(java.util.Calendar.HOUR_OF_DAY);
}

static int hours(long time) {
  return hours(calendarFromTime(time));
}

static int hours(long time, TimeZone tz) {
  return hours(calendarFromTime(time, tz));
}


static int roundDownTo_rev(int x, int n) {
  return roundDownTo(n, x);
}

static long roundDownTo_rev(long x, long n) {
  return roundDownTo(n, x);
}


static int minutes() {
  return minutes(java.util.Calendar.getInstance());
}

static int minutes(java.util.Calendar c) {
  return c.get(java.util.Calendar.MINUTE);
}


static long toK(long l) {
  return (l+1023)/1024;
}


static Collection<Concept> allConcepts() {
  return db_mainConcepts().allConcepts();
}

static Collection<Concept> allConcepts(Concepts concepts) {
  return concepts.allConcepts();
}



static long sysNow() {
  ping();
  return System.nanoTime()/1000000;
}


// firstDelay = delay
static FixedRateTimer doEvery_daemon(long delay, final Object r) { return doEvery_daemon(defaultTimerName(), delay, r); }
static FixedRateTimer doEvery_daemon(String timerName, long delay, final Object r) {
  return doEvery_daemon(timerName, delay, delay, r);
}

static FixedRateTimer doEvery_daemon(long delay, long firstDelay, final Object r) { return doEvery_daemon(defaultTimerName(), delay, firstDelay, r); }
static FixedRateTimer doEvery_daemon(String timerName, long delay, long firstDelay, final Object r) {
  FixedRateTimer timer = new FixedRateTimer(true);
  timer.scheduleAtFixedRate(smartTimerTask(r, timer, delay), firstDelay, delay);
  return timer;
}

static FixedRateTimer doEvery_daemon(double delaySeconds, final Object r) {
  return doEvery_daemon(toMS(delaySeconds), r);
}



  static int abs(int i) { return Math.abs(i); }


  static long abs(long i) { return Math.abs(i); }


  static float abs(float i) { return Math.abs(i); }


  static double abs(double i) { return Math.abs(i); }




static double abs(Complex c) { return c.abs(); }



static void closeAllOpt(Iterable l) {
  if (l == null) return;
  for (Object c : l) { try { if (c instanceof AutoCloseable) close((AutoCloseable) c); } catch (Throwable __e) { pcallFail(__e); }}
}

static void closeAllOpt(Object... l) {
  if (l == null) return;
  for (Object c : l) { try { if (c instanceof AutoCloseable) close((AutoCloseable) c); } catch (Throwable __e) { pcallFail(__e); }}
}


static void sleepInCleanUp(long ms) { try {
  if (ms < 0) return;
  Thread.sleep(ms);
} catch (Exception __e) { throw rethrow(__e); } }


static boolean cleanUp_interruptThreads = false; // experimental

static 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 : keysList((Map) c)) cleanUp(o);
    for (Object o : valuesList((Map) c)) cleanUp(o);
    syncClear((Map) c);
    return;
  }
  //if (!(c instanceof Class)) ret;
  
  try {
    // revoke license
    
    preCleanUp(c);
    
    // unpause
    
    setOpt_raw(c, "ping_pauseAll", false);
    
    // call custom cleanMeUp() and cleanMeUp_*() functions
    
    innerCleanUp(c);
        
    // Java spec says finalize should only be called by GC,
    // but we care to differ.
    // Edit: Not anymore (illegal access warnings)
    /*if (isTrue(vmMap_get('callFinalize)))
      pcallOpt(c, "finalize");*/

    // remove all virtual bots (hope this works)
    
    List androids = (List) getOpt(c, "record_list");
    for (Object android : unnull(androids))
      pcallOpt(android, "dispose"); // heck we'll dispose anything

    // sub-cleanup
    
    List<WeakReference> classes =  (List<WeakReference>) (getOpt(c, "hotwire_classes"));
    if (classes != null)
      for (WeakReference cc : classes) { try {
        cleanUp(cc.get());
      } catch (Throwable __e) { pcallFail(__e); }}
      
    // interrupt all threads (experimental, they might be doing cleanup?)
    
    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) { pcallFail(__e); }
  
  setOpt_raw(c, "cleaningUp_flag" , false);
  if (c instanceof Class && ((Class) c).getName().equals("main"))
    retireClassLoader(((Class) c).getClassLoader());
 }

static void cleanUp(Collection l) {
  if (l == null) return;
  for (Object c : l)
    cleanUp(c);
  l.clear();
}


static <A> A firstOfType(Collection c, Class<A> type) {
  for (Object x : c)
    if (isInstanceX(type, x))
      return (A) x;
  return null;
}


static List<Concept> conceptsOfType(String type) {
  return db_mainConcepts().conceptsOfType(type);
}


static <A> List<A> concatLists_conservative(List<A> a, List<A> b) {
  if (empty(a)) return b;
  if (empty(b)) return a;
  return concatLists(a, b);
}

static <A> List<A> concatLists_conservative(Collection<A> a, Collection<A> b) {
  if (empty(a) && b instanceof List) return ((List) b);
  if (empty(b) && a instanceof List) return ((List) a);
  return concatLists(a, b);
}


static <A> List<A> filterByType(Iterable c, Class<A> type) {
  List<A> l = new ArrayList();
  if (c != null) for (Object x : c)
    if (isInstanceX(type, x))
      l.add((A) x);
  return l;
}

static <A> List<A> filterByType(Object[] c, Class<A> type) {
  return filterByType(asList(c), type);
}

static <A> List<A> filterByType(Class<A> type, Iterable c) {
  return filterByType(c, type);
}


static <A> List<A> filterByDynamicType(Collection<A> c, String type) {
  List<A> l = new ArrayList();
  for (A x : c)
    if (eq(dynamicClassName(x), type))
      l.add(x);
  return l;
}


static boolean hasType(Collection c, Class type) {
  for (Object x : c)
    if (isInstanceX(type, x))
      return true;
  return false;
}


static <A extends Concept> A findBackRef(Concept c, Class<A> type) {
  for (Concept.Ref r : c.backRefs)
    if (instanceOf(r.concept(), type))
      return (A) r.concept();
  return null;
}

static <A extends Concept> A findBackRef(Class<A> type, Concept c) {
  return findBackRef(c, type);
}


static <A, B> void mapRemove(Map<A, B> map, A key) {
  if (map != null && key != null)
    map.remove(key);
}


static Concept cnew(String name, Object... values) {
  return cnew(db_mainConcepts(), name, values);
}

static Concept cnew(Concepts concepts, String name, Object... values) {
  Class<? extends Concept> cc = findClass(name);
  concepts_unlisted.set(true);
  Concept c;
  try {
    c = cc != null ? nuObject(cc) : new Concept(name);
  } finally {
    concepts_unlisted.set(null);
  }
  csetAll(c, values);
  concepts.register(c);
  return c;
}

static <A extends Concept> A cnew(Class<A> cc, Object... values) {
  return cnew(db_mainConcepts(), cc, values);
}

static <A extends Concept> A cnew(Concepts concepts, Class<A> cc, Object... values) {
  concepts_unlisted.set(true);
  A c;
  try {
    c = nuObject(cc);
  } finally {
    concepts_unlisted.set(null);
  }
  csetAll(c, values);
  concepts.register(c);
  return c;
}



static String loadConceptsStructure(String progID) {
  return loadTextFilePossiblyGZipped(getProgramFile(progID, "concepts.structure"));
}

static String loadConceptsStructure() {
  return loadConceptsStructure(dbProgramID());
}


static <A extends Concept> int countConcepts(Concepts concepts, Class<A> c, Object... params) {
  return concepts.countConcepts(c, params);
}

static <A extends Concept> int countConcepts(Class<A> c, Object... params) {
  return db_mainConcepts().countConcepts(c, params);
}

static int countConcepts() {
  return db_mainConcepts().countConcepts();
}

static int countConcepts(String className) {
  return db_mainConcepts().countConcepts(className);
}

static <A extends Concept> int countConcepts(Concepts concepts, String className) {
  return concepts.countConcepts(className);
}

static int countConcepts(Concepts concepts) {
  return concepts.countConcepts();
}


static <A, B> boolean containsKey(Map<A, B> map, A key) {
  return map != null && map.containsKey(key);
}


static <A> boolean syncAdd(Collection<A> c, A b) {
  if (c == null) return false;
  synchronized(collectionMutex(c)) { return c.add(b); }
}

static <A> void syncAdd(List<A> l, int idx, A b) {
  if (l != null) synchronized(collectionMutex(l)) { l.add(idx, b); }
}


static <A> boolean syncRemove(Collection<A> c, A b) {
  if (c == null) return false;
  synchronized(collectionMutex(c)) { return c.remove(b); }
}

static <A> A syncRemove(List<A> l, int idx) {
  if (l == null) return null;
  synchronized(collectionMutex(l)) { return l.remove(idx); }
}

static <A, B> B syncRemove(Map<A, B> map, A key) {
  return map == null ? null : map.remove(key);
}


static <A> List<A> syncAddOrCreate(List<A> l, A a) {
  if (l == null) l = syncList();
  l.add(a);
  return l;
}


static String nConcepts(long n) { return n2(n, "concept"); }
static String nConcepts(Collection l) { return nConcepts(l(l)); }
static String nConcepts(Map map) { return nConcepts(l(map)); }


static int identityHashCode(Object o) {
  return System.identityHashCode(o);
}


static String shortDynamicClassName(Object o) {
 if (o instanceof DynamicObject && ((DynamicObject) o).className != null)
    return ((DynamicObject) o).className;
  return shortClassName(o);
}


static boolean dynamicObjectIsLoading() { 
  return isUnstructuring();
}


static void assertIsInstance(Class type, Object o) {
  if (!isInstance(type, o))
    throw fail(_getClass(o) + " is not a subclass of " + type);
}

static void assertIsInstance(Object o, Class type) {
  assertIsInstance(type, o);
}


static String b(Object contents, Object... params) {
  return fulltag("b", contents, params);
}


static void change() {
  //mainConcepts.allChanged();
  // safe version for now cause function is sometimes included unnecessarily (e.g. by EGDiff)
  callOpt(getOptMC("mainConcepts"), "allChanged");
}


static boolean has(String a, String b, String c) {
  
  return false;
}

static boolean has(T3<String, String, String> t) {
  
  return false;
}


static void removeLast(List l) {
  if (!l.isEmpty())
    l.remove(l(l)-1);
}

static void removeLast(List l, int n) {
  removeSubList(l, l(l)-n);
}

static void removeLast(int n, List l) {
  removeLast(l, n);
}

static void removeLast(StringBuilder buf) {
  if (buf == null) return;
  int n = buf.length();
  if (n > 0) buf.setLength(n-1);
}


static <A> A syncGet(List<A> l, int idx) {
  if (l == null || idx < 0) return null;
  synchronized(l) {
    return idx < l(l) ? l.get(idx) : null;
  }
}

static <A, B> B syncGet(Map<A, B> map, A a) {
  if (map == null) return null;
  synchronized(map) {
    return map.get(a);
  }
}


static int syncL(Collection l) {
  if (l == null) return 0;
  synchronized(collectionMutex(l)) { return l.size(); }
}

static int syncL(Map map) {
  if (map == null) return 0;
  synchronized(collectionMutex(map)) { return map.size(); }
}

static <A> List<A> syncL() {
  return syncList();
}


static <A> List<A> addDyn_quickSync(List<A> l, A a) {
  if (l == null) l = new ArrayList();
  syncAdd(l, a);
  return l;
}


static <A> List<A> removeDyn_quickSync(List<A> l, A a) {
  if (l == null) return null;
  synchronized(collectionMutex(l)) {
    l.remove(a);
    return empty(l) ? null : l;
  }
}


static void crenameField_noOverwrite(Concept c, String oldField, String newField) {
  if (c == null || eq(oldField, newField)) return;
  Object value = cget(c, oldField);
  if (newField != null && cget(c, newField) == null) cset(c, newField, value);
  cset(c, oldField, null);
}


static Collection<Concept.Ref> scanConceptForRefs(Concept c) {
  Set<Concept.Ref> refs = new HashSet();
  if (c != null) for (Object o : values(objectToMap(c))) {
    if (o instanceof Concept.Ref)
      refs.add((Concept.Ref) o);
    else if (o instanceof Concept.RefL)
      addAll(refs, ((Concept.RefL) o).l);
  }
  return refs;
}


static Concepts concepts(Concept c) {
  return c == null ? null : c._concepts;
}


static String find(String pattern, String text) {
  Matcher matcher = Pattern.compile(pattern).matcher(text);
  if (matcher.find())
    return matcher.group(1);
  return null;
}

static <A> A find(Collection<A> c, Object... data) {
  for (A x : c)
    if (checkFields(x, data))
      return x;
  return null;
}


static String joinNemptiesWithColon(String... strings) {
  return joinNempties(": ", strings);
}

static String joinNemptiesWithColon(Collection<String> strings) {
  return joinNempties(": ", strings);
}


static WidthAndHeight widthAndHeight(BufferedImage image) {
  return image == null ? null : widthAndHeight(image.getWidth(), image.getHeight());
}

static WidthAndHeight widthAndHeight(int w) { return widthAndHeight(w, w); }
static WidthAndHeight widthAndHeight(int w, int h) {
  return new WidthAndHeightFinal(w, h);
}


public static boolean isWindows() {
  return System.getProperty("os.name").contains("Windows");
}


static String firstToUpper(String s) {
  if (empty(s)) return s;
  return Character.toUpperCase(s.charAt(0)) + s.substring(1);
}


static long stopTiming_defaultMin = 10;

static long startTiming_startTime;
static void startTiming() {
  startTiming_startTime = now();
}

static void stopTiming() {
  stopTiming(null);
}

static void stopTiming(String text) {
  stopTiming(text, stopTiming_defaultMin);
}

static void stopTiming(String text, long minToPrint) {
  long time = now()-startTiming_startTime;
  if (time >= minToPrint) {
    text = or2(text, "Time: ");
    print(text + time + " ms");
  }
}


static double sqrt(double x) {
  return Math.sqrt(x);
}


static Pt ptMinus(Pt a, Pt b) {
  if (b == null) return a;
  return new Pt(a.x-b.x, a.y-b.y);
}


static UnsupportedOperationException unsupportedOperation() {
  throw new UnsupportedOperationException();
}


static double infinity() {
  return positiveInfinity();
}


static long toMS(double seconds) {
  return (long) (seconds*1000);
}

static long toMS(Duration d) {
  return d == null ? 0 : d.toMillis();
}


static <A> MultiSetMap<Object, A> generalizedCIMultiSetMap() {
  MultiSetMap<Object, A> mm = new MultiSetMap();
  mm.data = generalizedCIMap();
  return mm;
}


static boolean eq_nullIfEmpty(String a, String b) {
  return eq(nullIfEmpty(a), nullIfEmpty(b));
}


static String apexDomain(String domain) {
  return regexpExtractIC("[a-z0-9\\-]+\\.[a-z]+$", domain);
}


static 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 Set<Class> allInterfacesImplementedBy(Object o) {
  return allInterfacesImplementedBy(_getClass(o));
}

static Set<Class> allInterfacesImplementedBy(Class c) {
  if (c == null) return null;
  HashSet<Class> set = new HashSet();
  allInterfacesImplementedBy_find(c, set);
  return set;
}

static 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 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 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 String getClientIPFromHeaders(Map<String, String> headers) {
  //print("All headers: " + sfu(headers));
  if (headers == null) return null;
  String remoteAddr =  (String) (headers.get("remote-addr"));
  String client =  (String) (headers.get("x-forwarded-for"));
  if (nempty(client)) remoteAddr += "," + client;
  return remoteAddr;
}


static String lower(String s) {
  return s == null ? null : s.toLowerCase();
}

static char lower(char c) {
  return Character.toLowerCase(c);
}


static String domain() {
  return domainName();
}

static String domain(String url) {
  return hostNameFromURL(url);
}


static File googleClientSecretFileForDomain(String domain) {
  if (!isSimpleDomainName(domain)) return null;
  return firstThat(listFiles(javaxSecretDir(domain)),
    f -> startsWith(fileName(f), "client_secret") && endsWith(fileName(f), ".json"));
}


static Map decodeJSONMap(String s) {
  return jsonDecodeMap(s);
}


static String md5(String text) { try {
  if (text == null) return "-";
  return bytesToHex(md5AsByteArray(toUtf8(text))); // maybe different than the way PHP does it...
} catch (Exception __e) { throw rethrow(__e); } }

static String md5(byte[] data) {
  if (data == null) return "-";
  return bytesToHex(md5AsByteArray(data));
}

static String md5(File file) {
  return md5OfFile(file);
}


static void dbIndexing(Object... params) {
  db();
  indexConceptFields(params);
}


static void dm_restartOnFieldChange(String field) {
  dm_reloadOnFieldChange(field);
}


static Thread dm_startThread(Runnable r) { return dm_startThread(defaultThreadName(), r); }
static Thread dm_startThread(String name, Runnable r) {
  return startThread(name, r);
}







static SNIKeyManager serverSocketFactory_botCompanyEtc_keyManager;

static String serverSocketFactory_botCompanyEtc_passphrase = "botcompany";
static File serverSocketFactory_botCompanyEtc_trustKeyStoreFile;

static char[] serverSocketFactory_botCompanyEtc_getPassphrase() {
  return getChars(serverSocketFactory_botCompanyEtc_passphrase);
}

static SNIKeyManager serverSocketFactory_botCompanyEtc_makeSNIKeyManager() {
  return new SNIKeyManager(serverSocketFactory_botCompanyEtc_makeKeyManagerMap());
}

static Map<String, Pair<X509KeyManager, String>> serverSocketFactory_botCompanyEtc_makeKeyManagerMap() {
  List<File> dirs = sortByFileName(listDirsContainingFileNamed(javaxSecretDir(), "keystore.p12"));
  char[] serverSocketFactory_botCompanyEtc_passphrase = serverSocketFactory_botCompanyEtc_getPassphrase();
  return (Map) mapToOrderedMap(dirs, dir -> pair(fileName(dir), 
    pair(keyManagerFromKeyStore(newFile(dir, "keystore.p12"), serverSocketFactory_botCompanyEtc_passphrase), fileName(dir))));
}

static SSLServerSocketFactory serverSocketFactory_botCompanyEtc() { try {
  serverSocketFactory_botCompanyEtc_trustKeyStoreFile = anyKeyStore();
  if (serverSocketFactory_botCompanyEtc_trustKeyStoreFile == null) return (SSLServerSocketFactory) SSLServerSocketFactory.getDefault();
  KeyStore trustKeyStore = keyStoreFromFile(serverSocketFactory_botCompanyEtc_trustKeyStoreFile, serverSocketFactory_botCompanyEtc_getPassphrase());
  SNIKeyManager wrappedKeyManager = serverSocketFactory_botCompanyEtc_makeSNIKeyManager();
  serverSocketFactory_botCompanyEtc_keyManager = wrappedKeyManager;
  //wrappedKeyManager.verbose = true;
    
  TrustManagerFactory trustManagerFactory = TrustManagerFactory.getInstance(TrustManagerFactory.getDefaultAlgorithm());
  trustManagerFactory.init(trustKeyStore);

  SSLContext ctx = SSLContext.getInstance("TLS");
  ctx.init(new KeyManager[] {wrappedKeyManager}, trustManagerFactory.getTrustManagers(), null);
  
  return ctx.getServerSocketFactory();
} catch (Exception __e) { throw rethrow(__e); } }

static void serverSocketFactory_botCompanyEtc_update() {
  serverSocketFactory_botCompanyEtc_keyManager.keyManagersByDomain = serverSocketFactory_botCompanyEtc_makeKeyManagerMap();
}




// firstDelay = delay
static FixedRateTimer dm_doEvery(long delay, Runnable r) {
  return dm_ownTimer(doEvery(delay, delay, dm_rEnter(r)));
}

static FixedRateTimer dm_doEvery(long delay, long firstDelay, Runnable r) {
  return dm_ownTimer(doEvery(delay, firstDelay, dm_rEnter(r)));
}

// reversed argument order for fun
static FixedRateTimer dm_doEvery(double initialSeconds, double delaySeconds, Runnable r) {
  return dm_ownTimer(doEvery(initialSeconds, delaySeconds, dm_rEnter(r)));
}

static FixedRateTimer dm_doEvery(double delaySeconds, Runnable r) {
  return dm_ownTimer(doEvery(delaySeconds, dm_rEnter(r)));
}




static void ownResource(AutoCloseable c) {
  _registerAutoCloseable(c);
}


static AutoCloseable serverSocketFactory_autoUpdate() { return serverSocketFactory_autoUpdate(null); }
static AutoCloseable serverSocketFactory_autoUpdate(IF0<AutoCloseable> enter) { 
   CloseablesHolder resources = new CloseablesHolder(); try {
  FileWatchService watchService = new FileWatchService();
  resources.add(watchService);
  
  File dir = mkdirs(javaxSecretDir());
  watchService.addRecursiveListener(dir, f -> {
     AutoCloseable __1 = getVar(enter); try {
    if (fileNameIs(f, "keystore.p12")) {
      print("Key store changed, reloading certificates: " + f);
      serverSocketFactory_botCompanyEtc_update();
    }
  } finally { _close(__1); }});
  print("Watching " + dir + " for keystore changes");
  return resources.takeOut(watchService);
} finally { _close(resources); }}


static double elapsedSeconds_timestamp(long time) {
  return toSeconds(now()-time);
}


static String nSessions(long n) { return n2(n, "session"); }
static String nSessions(Collection l) { return nSessions(l(l)); }
static String nSessions(Map map) { return nSessions(l(map)); }


static void deleteConcepts(Collection conceptsOrIDs) {
  db_mainConcepts().deleteConcepts(asList(conceptsOrIDs));
}

static <A extends Concept> List<A> deleteConcepts(Class<A> c, Object... params) { return deleteConcepts(db_mainConcepts(), c, params); }
static <A extends Concept> List<A> deleteConcepts(Concepts cc, Class<A> c, Object... params) {
  List<A> l = asList(findConceptsWhere(cc, c, params));
  deleteConcepts(l);
  return l;
}

static <A extends Concept> List<A> deleteConcepts(Class<A> c, IF1<A, Boolean> pred) { return deleteConcepts(db_mainConcepts(), c, pred); }
static <A extends Concept> List<A> deleteConcepts(Concepts cc, Class<A> c, IF1<A, Boolean> pred) {
  var l = filter(list(cc, c), pred);
  deleteConcepts(l);
  return l;
}

static List<Concept> deleteConcepts(Concepts cc) {
  return deleteConcepts(cc, Concept.class);
}



static boolean dm_moduleIsStartingOrReloading(Object moduleOrID) {
  return dm_moduleIsStarting(moduleOrID) || dm_moduleIsReloading(moduleOrID);
}


static <A> A dm_callOpt(Object moduleOrID, String method, Object... args) {
  return dm_callModuleOpt(moduleOrID, method, args);
}


// returns last value of predicate
static boolean sleepWhile(IF0<Boolean> pred, Object... __) {
  int interval = optPar("interval", __,  50); // ms
  double max = optPar("max", __,  10.0); // seconds
  long time = sysNow();
  do {
    if (!pred.get()) return false;
    sleep(interval);
  } while (sysNow() <= time+toMS(max));
  return true;
}


static Object subBot_serve500() {
  return call(getMainBot(), "serve500");
}

static Object subBot_serve500(String msg) {
  return call(getMainBot(), "serve500", msg);
}

static Object subBot_serve500(Throwable error) {
  return subBot_serve500(renderStackTrace(error));
}


static Object eleu_callModuleHTMLMethod(Object module, Object req) {
  if (!dm_moduleIsStarted(module))
    return serve500(print("Module not started"));
    
  dm_call(module, "setEleu", or(mainBot(), mc()));
  Method htmlMethod = first(singleArgumentMethods(findMethodsNamed_nonSynthetic(dm_mod(module), "html")));
  if (htmlMethod == null) throw fail("HTML method not found in module " + module);
  Class reqType = firstMethodArgumentType(htmlMethod);
  Object wrappedReq = req;
  if (isInterface(reqType))
    wrappedReq = proxy(reqType, req);
  return dm_call(module, "html", wrappedReq);
}


static Object subBot_serve404() {
  return call(getMainBot(), "serve404");
}

static Object subBot_serve404(String msg) {
  return call(getMainBot(), "serve404", msg);
}


 // google http client
 // google api client
 // google oauth client
 // jackson
 // google jackson2
 // google http client appengine







static Payload googleVerifyUserToken2(String clientID, String token) { try {
  print("Google verify started.");
  
  NetHttpTransport transport = new NetHttpTransport();
  
  GoogleIdTokenVerifier verifier = new GoogleIdTokenVerifier.Builder(transport, new JacksonFactory())
    .setAudience(Collections.singletonList(clientID))
    .build();
  
  GoogleIdToken idToken = verifier.verify(token);
  if (idToken != null) {
    Payload payload = idToken.getPayload();
    print("Google verify confirmed: " + payload.getEmail());
    return payload;
  }
  
  print("Google verify failed");
  return null;
} catch (Exception __e) { throw rethrow(__e); } }


static <A extends Concept> A uniqCI_sync(final Class<A> c, final Object... params) {
  return uniqCI(c, params);
}

static <A extends Concept> A uniqCI_sync(Concepts concepts, Class<A> c, final Object... params) {
  return uniqCI(concepts, c, params);
}


static void internalFrameMenuItem(Container f, final String name, final Object action) {
  internalFrameTitlePopupMenuItem(((JInternalFrame) f), name, action);
}


static List<String> quoteAll(String[] l) {
  return quoteAll(asList(l));
}

static List<String> quoteAll(Collection<String> l) {
  List<String> x = new ArrayList();
  for (String s : l)
    x.add(quote(s));
  return x;
}


static 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 Object metaGet(IMeta o, Object key) {
  return metaMapGet(o, key);
}

static Object metaGet(Object o, Object key) {
  return metaMapGet(o, key);
}

static Object metaGet(String key, IMeta o) {
  return metaMapGet(o, key);
}

static Object metaGet(String key, Object o) {
  return metaMapGet(o, key);
}


static Object metaMapGet(IMeta o, Object key) {
  return o == null ? null : o.metaGet(key); // We now let the object itself do it (overridable!)
}

static Object metaMapGet(Object o, Object key) {
  return metaMapGet(toIMeta(o), key);
}


static void metaPut(IMeta o, Object key, Object value) {
  metaMapPut(o, key, value);
}



static void metaPut(Object o, Object key, Object value) {
  metaMapPut(o, key, value);
}


static Map convertObjectMetaToMap(IMeta o) { return convertObjectMetaToMap(o, () -> makeObjectMetaMap()); }
static Map convertObjectMetaToMap(IMeta o, IF0<Map> createEmptyMap) {
  if (o == null) return null;
  
  // The following shortcut depends on the assumption that a meta field never reverts
  // to null when it was a map
  
    Object meta = o._getMeta();
    if (meta instanceof Map) return ((Map) meta);
  
  
  // non-shortcut path (create 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 <A, B> void syncMapPutOrRemove(Map<A, B> map, A key, B value) {
  syncMapPut2(map, key, value);
}


static void close(AutoCloseable c) {
  _close(c);
}


static <B, A extends B> A addAndReturn(Collection<B> c, A a) {
  if (c != null) c.add(a);
  return a;
}

static <B, A extends B> A addAndReturn(List<B> c, int idx, A a) {
  if (c != null) c.add(idx, a);
  return a;
}


  static File tempDir() {
    return makeTempDir();
  }


static File createTempFile() {
  return createTempFile("tmp", null);
}

static File createTempFile(String prefix, String suffix) { try {
  prefix = nohup_sanitize(prefix);
  suffix = nohup_sanitize(suffix);
  if (shouldKeepTempFiles())
    return mkdirsForFile(javaxCachesDir("Temp/" + prefix + "-" + randomID() + "-" + suffix));
  // File.createTempFile needs at least 3 prefix characters, so we
  // fíll them up for you
  File f = File.createTempFile(takeFirst(10, pad(prefix, 3, '-')), suffix);
  f.deleteOnExit();
  return f;
} catch (Exception __e) { throw rethrow(__e); } }


static <A> A printWithIndent(A o) {
  return printIndent(o);
}



static <A> A printWithIndent(String indent, A o) {
  return printIndent(indent, o);
}



static void printWithIndent(int indent, Object o) {
  printIndent(indent, o);
}


static HashMap lithashmap(Object... x) {
  return litmap(x);
}


// name currently not used, we only call a method called "_wrap" in
// the main class with the to-wrapped object as first argument and
// a list of other parameters as second argument.
static <A> A wrapStuff(String name, A object, Object... args) {
  //ret or(object, (A) callOpt(mc(), "wrap" + name,
  //  toObjectArray(concatLists(litlist((O) object), toList(args)))));
  return or((A) callOpt(mc(), "_wrap", object, asList(args)), object);
}


static void printMyIPs() {
String ip;
  try {
      Enumeration<NetworkInterface> interfaces = NetworkInterface.getNetworkInterfaces();
      while (interfaces.hasMoreElements()) {
          NetworkInterface iface = interfaces.nextElement();
          // filters out 127.0.0.1 and inactive interfaces
          if (iface.isLoopback() || !iface.isUp())
              continue;

          Enumeration<InetAddress> addresses = iface.getInetAddresses();
          while(addresses.hasMoreElements()) {
              InetAddress addr = addresses.nextElement();
              ip = addr.getHostAddress();
if (ip.startsWith("127.")) continue;
boolean local = addr.isSiteLocalAddress() || ip.startsWith("fe");
              System.out.println(iface.getDisplayName() + " " + ip + " " + (local ? "(private address)" : "(public address)"));
          }
      }
  } catch (Throwable e) {
      e.printStackTrace();
  }
}


static <A> A getAndClear(IVar<A> v) {
  A a = v.get();
  v.set(null);
  return a;
}


static <A, B> Set<A> keySet(Map<A, B> map) {
  return map == null ? new HashSet() : map.keySet();
}

static Set keySet(Object map) {
  return keys((Map) map);
}


  static <A> Set<A> keySet(MultiSet<A> ms) {
    return ms.keySet();
  }



  static <A, B> Set<A> keySet(MultiMap<A, B> mm) {
    return mm.keySet();
  }





static <A, B> int keysSize(MultiMap<A, B> mm) {
  return lKeys(mm);
}


static <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 String formatDouble_significant2(double d, int digits) {
  try {
    digits -= Math.floor(max(-10, Math.log10(abs(d))+1));
    return formatDouble(d, digits);
  } catch (Throwable _e) {
    print("Had number: " + d + ", digits: " + digits);
  
throw rethrow(_e); }
}


static File loadLibrary(String snippetID) {
  return loadBinarySnippet(snippetID);
}


// TODO: use actualUserHome()?
// (there was a problem with onLocallyInferiorJavaX() always triggering inside #1013896)

static File pathToJavaxJar() {
  
    
    IResourceLoader rl = vm_getResourceLoader();
    if (rl != null)
      return rl.pathToJavaXJar();
    
    
    return pathToJavaxJar_noResourceLoader();
  
  
}
    
static 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 boolean hasNext(Iterator it) {
  return it != null && it.hasNext();
}


static Method hashMap_findKey_method;

static <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);
  // java.util.Map.Entry<A, B> entry = (java.util.Map.Entry) call(hash, 'getNode, hashMap_internalHash(key), wkey);
  return entry == null ? null : entry.getKey();
} catch (Exception __e) { throw rethrow(__e); } }


static String a(String noun) {
  if (eq(noun, "")) return "?";
  return ("aeiou".indexOf(noun.charAt(0)) >= 0 ? "an " : "a ") + noun;
}

static String a(String contents, Object... params) {
  return hfulltag("a", contents, params);
}



static int hashCodeFor(Object a) {
  return a == null ? 0 : a.hashCode();
}


static String windowsLineBreaks(String s) {
  return s == null ? null : s.replaceAll("(?<!\r)\n", "\r\n");
}


static List<String> withoutStartingWithIC(Collection<String> l, final String prefix) {
  return notStartingWithIC(l, prefix);
}



static List<String> withoutStartingWithIC(String prefix, Collection<String> l) {
  return notStartingWithIC(prefix, l);
}


static <A> A printQuoted(A a) { return printQuoted("", a); }
static <A> A printQuoted(String prefix, A a) {
  return printQuote(prefix, a);
}




static ThreadLocal<MouseEvent> componentPopupMenu_mouseEvent;

static void componentPopupMenu_init() {
  { swing(() -> { 
    if (componentPopupMenu_mouseEvent == null)
      componentPopupMenu_mouseEvent = (ThreadLocal<MouseEvent>) vm_generalMap_get("mouseEvent");
    if (componentPopupMenu_mouseEvent == null)
      vm_generalMap_put("componentPopupMenu_mouseEvent" , componentPopupMenu_mouseEvent = new ThreadLocal());
  }); }
}

static void componentPopupMenu(final JComponent component, IVF1<JPopupMenu> menuMaker) {
  componentPopupMenu(component, (Object) menuMaker);
}

// menuMaker = voidfunc(JPopupMenu)
static void componentPopupMenu(final JComponent component, final Object menuMaker) {
  if (component == null || menuMaker == null) return;
  { swing(() -> { 
    Object adapter = componentPopupMenu_initForComponent(component);
    ((List) _get(adapter, "maker")).add(menuMaker);
  }); }
}

static Object componentPopupMenu_initForComponent(final JComponent component) {
  return component == null ? null : swing(new F0<Object>() { public Object get() { try { 
    componentPopupMenu_init();
    Object adapter = findComponentPopupMenuListener_gen(component);
    if (adapter == null) {
      componentPopupMenu_Adapter a = new componentPopupMenu_Adapter();
      //addMouseListener_inFront(component, a);
      component.addMouseListener(a);
      adapter = a;
    }
    return adapter;
   } catch (Exception __e) { throw rethrow(__e); } }
  public String toString() { return "componentPopupMenu_init();\r\n    O adapter = findComponentPopupMenuListener_ge..."; }});
}

static class componentPopupMenu_Adapter extends MouseAdapter {
  List maker = new ArrayList();
  boolean internalFrameLeftButtonMagic = false;
  boolean allowScrolling = true;
  
  Point pressedAt;

  public void mousePressed(MouseEvent e) {
    displayMenu(e);
    pressedAt = internalFrameLeftButtonMagic && e.getClickCount() == 1 && internalFrameActive(e.getComponent()) ? e.getLocationOnScreen() : null;
  }
  
  public void mouseReleased(MouseEvent e) {
    // TODO: show a little less often on left mouse click
    if (internalFrameLeftButtonMagic && eq(pressedAt, e.getLocationOnScreen()))
      displayMenu2(e);
    else
      displayMenu(e);
  }

  void displayMenu(MouseEvent e) {
    if (e.getSource() instanceof JInternalFrame) return;
    if (e.isPopupTrigger()) displayMenu2(e);
  }

  void populate(JPopupMenu menu, MouseEvent e) {  
     AutoCloseable __1 = tempSetTL(componentPopupMenu_mouseEvent, e); try {
    for (Object menuMaker : maker)
      pcallF(menuMaker, menu);
    vmBus_send("showingPopupMenu", e.getComponent(), menu);
  } finally { _close(__1); }}
    
  void displayMenu2(MouseEvent e) {
    new PopupMenuMaker(e, menu -> populate(menu, e))
      .allowScrolling(allowScrolling).run();
  }
}




static <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 <A extends JComponent> A setToolTipText(Object toolTip, A c) {
  return setToolTipText(c, toolTip);
}




static 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 <A, B> LinkedHashMap<A, B> cloneLinkedHashMap(Map<A, B> map) {
  return map == null ? new LinkedHashMap() : new LinkedHashMap(map);
}


static <A> A second(List<A> l) {
  return get(l, 1);
}

static <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 <A> A second(A[] bla) {
  return bla == null || bla.length <= 1 ? null : bla[1];
}


static <A, B> B second(Pair<A, B> p) {
  return p == null ? null : p.b;
}



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



static <A> A second(Producer<A> p) {
  if (p == null) return null;
  if (p.next() == null) return null;
  return p.next();
}


static char second(String s) {
  return charAt(s, 1);
}


static <A, B> B second(Either<A, B> e) {
  return e == null ? null : e.bOpt();
}



static double fileAgeInSeconds(File f) {
  return f == null ? -1 : msToSeconds(now()-fileModificationTime(f));
}


static String nSeconds(long n) { return n2(n, "second"); }
static String nSeconds(Collection l) { return nSeconds(l(l)); }


static int iceil(double d) {
  return (int) Math.ceil(d);
}


static boolean deleteFile(File file) {
  return file != null && file.delete();
}




static Path toPath(File f) {
  return f == null ? null : f.toPath();
}


static void printExceptionShort(Throwable e) { printExceptionShort("", e); }
static void printExceptionShort(String prefix, Throwable e) {
  print(prefix, exceptionToStringShort(e));
}


static File saveTextFileWithoutTemp(File file, String contents) { try {
  mkdirsForFile(file);
   var fileOutputStream = newFileOutputStream(file); try {
  var outputStreamWriter = new OutputStreamWriter(fileOutputStream, "UTF-8");
  var printWriter = new PrintWriter(outputStreamWriter);
  printWriter.print(unnull(contents));
  printWriter.close();
  return file;
} finally { _close(fileOutputStream); }} catch (Exception __e) { throw rethrow(__e); } }


// firstDelay = delay
static FixedRateTimer doEvery(long delay, final Object r) {
  return doEvery(delay, delay, r);
}

static FixedRateTimer doEvery(long delay, long firstDelay, final Object r) {
  FixedRateTimer timer = new FixedRateTimer(shorten(programID() + ": " + r, 80));
  timer.scheduleAtFixedRate(smartTimerTask(r, timer, toInt(delay)), toInt(firstDelay), toInt(delay));
  return vmBus_timerStarted(timer);
}

// reversed argument order for fun
static FixedRateTimer doEvery(double initialSeconds, double delaySeconds, final Object r) {
  return doEvery(toMS(delaySeconds), toMS(initialSeconds), r);
}

static FixedRateTimer doEvery(double delaySeconds, final Object r) {
  return doEvery(toMS(delaySeconds), r);
}



// will create the file or update its last modified timestamp
static File touchFile(File file) { try {
  closeRandomAccessFile(newRandomAccessFile(mkdirsForFile(file), "rw"));
  return file;
} catch (Exception __e) { throw rethrow(__e); } }


static volatile int numberOfCores_value;

static int numberOfCores() {
  if (numberOfCores_value == 0)
    numberOfCores_value = Runtime.getRuntime().availableProcessors();
  return numberOfCores_value;
}


static int random(int n) { return random(n, defaultRandomGenerator()); }
static int random(int n, Random r) {
  return random(r, n);
}

static long random(long n) { return random(n, defaultRandomGenerator()); }
static long random(long n, Random r) {
  return random(r, n);
}

static int random(Random r, int n) {
  return n <= 0 ? 0 : getRandomizer(r).nextInt(n);
}

static long random(Random r, long n) {
  return n <= 0 ? 0 : getRandomizer(r).nextLong(n);
}

static double random(double max) {
  return random()*max;
}

static double random() {
  return defaultRandomGenerator().nextInt(100001)/100000.0;
}

static double random(double min, double max) {
  return min+random()*(max-min);
}

// min <= value < max
static int random(int min, int max) {
  return min+random(max-min);
}

// min <= value < max
static long random(long min, long max) {
  return min+random(max-min);
}

static int random(int min, int max, Random r) {
  return random(r, min, max);
}

static int random(Random r, int min, int max) {
  return min+random(r, max-min);
}

static <A> A random(List<A> l) {
  return oneOf(l);
}

static <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 <A, B> Pair<A, B> random(Map<A, B> map) {
  return entryToPair(random(entries(map)));
}


// Yes the nomenclature is a bit illogical

static <A> Chain<A> chainPlus(Chain<A> chain, A a) {
  return new Chain<A>(a, chain);
}

static <A> Chain<A> chainPlus(Chain<A> chain, A... l) {
  for (A a : unnullForIteration(l))
    chain = chainPlus(chain, a);
  return chain;
}

static <A> ReverseChain<A> chainPlus(ReverseChain<A> chain, A a) {
  return new ReverseChain<A>(chain, a);
}

static <A> ReverseChain<A> chainPlus(ReverseChain<A> chain, A... l) {
  for (A a : unnullForIteration(l))
    chain = chainPlus(chain, a);
  return chain;
}


static <A> AppendableChain<A> chainPlus(AppendableChain<A> chain, A a) {
  if (chain == null) return new AppendableChain<A>(a);
  chain.add(a);
  return chain;
}

static <A> AppendableChain<A> chainPlus(AppendableChain<A> chain, A... l) {
  for (A a : unnullForIteration(l))
    chain = chainPlus(chain, a);
  return chain;
}




static void syncNotifyAll(Object o) {
  if (o != null) synchronized(o) { o.notifyAll(); }
}


static void register(Concept c) {
  registerConcept(c);
}


static <A, B> List<A> cloneKeys_noSync(Map<A, B> map) {
  return cloneList_noSync(keys(map));
}


static <A, B> IterableIterator<B> navigableMultiSetMapValuesIterator_concurrent(final MultiSetMap<A, B> mm) {
  return navigableMultiSetMapValuesIterator_concurrent(mm, mm.data);
}
  
static <A, B> IterableIterator<B> navigableMultiSetMapValuesIterator_concurrent(final MultiSetMap<A, B> mm, Object mutex) {
  return iteratorFromFunction(new F0<B>() {
    Iterator<Set<B>> it = concurrentlyIterateValues((NavigableMap) mm.data, mutex);
    Iterator<B> it2;
    
    public B get() {
      while (it2 == null || !it2.hasNext()) {
        if (!it.hasNext()) return null;
        it2 = iterator(asList(it.next()));
      }
      return it2.next();
    }
  });
}


static <A, B> MultiSet<A> multiSetMapToMultiSet(MultiSetMap<A, B> mm) {
  MultiSet<A> ms = new MultiSet();
  for (A a : keys(mm))
    ms.add(a, l(mm.get(a)));
  return ms;
}


static Set asSet(Object[] array) {
  HashSet set = new HashSet();
  for (Object o : array)
    if (o != null)
      set.add(o);
  return set;
}

static Set<String> asSet(String[] array) {
  TreeSet<String> set = new TreeSet();
  for (String o : array)
    if (o != null)
      set.add(o);
  return set;
}

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


// Note: does not clone the set (keeps multiset alive)
static <A> Set<A> asSet(MultiSet<A> ms) {
  return ms == null ? null : ms.asSet();
}



static <A, B> NavigableSet<A> navigableKeys(NavigableMap<A, B> map) {
  return map == null ? new TreeSet() : map.navigableKeySet();
}


  static <A> NavigableSet<A> navigableKeys(MultiSet<A> ms) {
    return ((NavigableMap) ms.map).navigableKeySet();
  }



  static <A, B> NavigableSet<A> navigableKeys(MultiMap<A, B> mm) {
    return ((NavigableMap) mm.data).navigableKeySet();
  }



static <A, B> Map<A, List<B>> toMap(MultiMap<A, B> m) {
  return multiMapToMap(m);
}


static <A> Set<A> syncSet() {
  return synchroHashSet();
}

static <A> Set<A> syncSet(Collection<A> l) {
  return addAllAndReturnCollection(synchroHashSet(), l);
}


static ServerSocket makeServerSocket() { try {
  for (int port = 10000; port < 65535; port++) {
    try {
      return new ServerSocket(port);
    } catch (IOException e) {
      // try next port
    }
  }
  throw fail("No free port found (tried 10000-65535)");
} catch (Exception __e) { throw rethrow(__e); } }


static <A> MultiMap<String, A> ciMultiMap() {
  return caseInsensitiveMultiMap();
}


static boolean socketIsLocalhost(Socket s) {
  return s != null && s.getInetAddress().isLoopbackAddress();
}


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

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


static String readHttpHeaderLine(InputStream inputStream) throws IOException {
  ByteArrayOutputStream byteArrayOutputStream = new ByteArrayOutputStream();
  int c;
  for (c = inputStream.read(); c != '\n' && c != -1 ; c = inputStream.read())
    if (c != '\r')
      byteArrayOutputStream.write(c);
  if (c == -1 && byteArrayOutputStream.size() == 0) return null;
  return byteArrayOutputStream.toString("US-ASCII");
}


static String dropPrefixIgnoreCase(String prefix, String s) {
  return startsWithIgnoreCase(s, prefix) ? s.substring(l(prefix)) : s;
}


static boolean containsLine(String text, String line) {
  return contains(linesIterator(text), line);
}


static String fromUtf8(byte[] bytes) { try {
  return bytes == null ? null : new String(bytes, utf8charset());
} catch (Exception __e) { throw rethrow(__e); } }


static String addPortToHost_drop80(String host, int port) {
  return beforeColonOrAll(host) + (port == 80 ? "" : ":" + port);
}


static void joinThreads(Thread... l) {
  for (Thread t : l) joinThread(t);
}

static void joinThreads(Iterable<Thread> l) {
  for (Thread t : unnull(l)) joinThread(t);
}


static boolean isIOException(Throwable e) {
  return containsExceptionOfType(IOException.class, e);
}


static String renderStackTrace(StackTraceElement[] st) {
  return stackTraceToString(st);
}

static String renderStackTrace(Throwable e) {
  return stackTraceToString(e);
}

static String renderStackTrace(String msg) {
  return renderStackTrace(new Throwable(msg));
}


static RuntimeException unimplemented() {
  throw fail("TODO");
}

static RuntimeException unimplemented(String msg) {
  throw fail("TODO: " + msg);
}

static RuntimeException unimplemented(Object obj) {
  throw fail("TODO: implement method in " + className(obj));
}


static URI uri(String uri) { try {
  return new URI(uri);
} catch (Exception __e) { throw rethrow(__e); } }


static long waitForBotStartUp_timeoutSeconds = 60;

// returns address or fails
static String waitForBotStartUp(String botName) {
  for (int i = 0; i < waitForBotStartUp_timeoutSeconds; i++) {
    sleepSeconds(i == 0 ? 0 : 1);
    String addr = getBotAddress(botName);
    if (addr != null)
      return addr;
  }
  throw fail("Bot not found: " + quote(botName));
}


static Object rpc(String botName, String method, Object... args) {
  return unstructure_matchOK2OrFail(
    sendToLocalBot(botName, rpc_makeCall(method, args)));
}

static Object rpc(DialogIO bot, String method, Object... args) {
  return unstructure_matchOK2OrFail(
    bot.ask(rpc_makeCall(method, args)));
}

static String rpc_makeCall(String method, Object... args) {
  if (empty(args))
    return "call " + method;
  return format("call *", concatLists((List) ll(method), asList(args)));
}


static String nFragments(long n) { return n2(n, "fragment"); }
static String nFragments(Collection l) { return nFragments(l(l)); }
static String nFragments(Map map) { return nFragments(l(map)); }


  static String base64encode(byte[] a) {
    int aLen = a.length;
    int numFullGroups = aLen/3;
    int numBytesInPartialGroup = aLen - 3*numFullGroups;
    int resultLen = 4*((aLen + 2)/3);
    StringBuffer result = new StringBuffer(resultLen);
    char[] intToAlpha = intToBase64;

    // Translate all full groups from byte array elements to Base64
    int inCursor = 0;
    for (int i=0; i<numFullGroups; i++) {
      int byte0 = a[inCursor++] & 0xff;
      int byte1 = a[inCursor++] & 0xff;
      int byte2 = a[inCursor++] & 0xff;
      result.append(intToAlpha[byte0 >> 2]);
      result.append(intToAlpha[(byte0 << 4)&0x3f | (byte1 >> 4)]);
      result.append(intToAlpha[(byte1 << 2)&0x3f | (byte2 >> 6)]);
      result.append(intToAlpha[byte2 & 0x3f]);
    }

    // Translate partial group if present
    if (numBytesInPartialGroup != 0) {
      int byte0 = a[inCursor++] & 0xff;
      result.append(intToAlpha[byte0 >> 2]);
      if (numBytesInPartialGroup == 1) {
        result.append(intToAlpha[(byte0 << 4) & 0x3f]);
        result.append("==");
      } else {
        // assert numBytesInPartialGroup == 2;
        int byte1 = a[inCursor++] & 0xff;
        result.append(intToAlpha[(byte0 << 4)&0x3f | (byte1 >> 4)]);
        result.append(intToAlpha[(byte1 << 2)&0x3f]);
        result.append('=');
      }
    }
    // assert inCursor == a.length;
    // assert result.length() == resultLen;
    return result.toString();
  }

  /**
   * This array is a lookup table that translates 6-bit positive integer
   * index values into their "Base64 Alphabet" equivalents as specified
   * in Table 1 of RFC 2045.
   */
  static final char intToBase64[] = {
    'A', 'B', 'C', 'D', 'E', 'F', 'G', 'H', 'I', 'J', 'K', 'L', 'M',
    'N', 'O', 'P', 'Q', 'R', 'S', 'T', 'U', 'V', 'W', 'X', 'Y', 'Z',
    'a', 'b', 'c', 'd', 'e', 'f', 'g', 'h', 'i', 'j', 'k', 'l', 'm',
    'n', 'o', 'p', 'q', 'r', 's', 't', 'u', 'v', 'w', 'x', 'y', 'z',
    '0', '1', '2', '3', '4', '5', '6', '7', '8', '9', '+', '/'
  };


static 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 java.util.Timer doLater(double delaySeconds, final Object r) {
  return doLater(toMS(delaySeconds), r);
}


static Timestamp sysTimeToTimestamp(long now) {
  return now == 0 ? null : new Timestamp(now - clockToSysTimeDiff());
}


static Timestamp tsNow() {
  return new Timestamp();
}





static WatchEvent.Kind[] jdk_watchService_allEventKinds() {
  return new WatchEvent.Kind[] {ENTRY_CREATE, ENTRY_DELETE, ENTRY_MODIFY, OVERFLOW};
}


static <A> Set<A> synchroSet() {
  return synchroHashSet();
}

static <A> Set<A> synchroSet(Set<A> set) {
  return synchronizedSet(set);
}


static List<File> findAllDirs(File dir) {
  List<File> out = new ArrayList();
  findAllDirs(dir, out);
  return out;
}

static 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 <A> IterableIterator<A> reversedIterator(final List<A> l) {
  return new IterableIterator<A>() {
    int i = l(l)-1;

    public boolean hasNext() { return i >= 0; }
    public A next() { return l.get(i--); }
  };
}


static int getWidth(Component c) {
  return c == null ? 0 : (int) swingCall(c, "getWidth");
}


static int getHeight(Component c) {
  return c == null ? 0 : (int) swingCall(c, "getHeight");
}


static Rect rect(int x, int y, int w, int h) {
  return new Rect(x, y, w, h);
}

static Rect rect(Pt p, int w, int h) {
  return new Rect(p.x, p.y, w, h);
}

static Rect rect(int w, int h) {
  return new Rect(0, 0, w, h);
}




static long longMul(long a, long b) {
  return a*b;
}


static <A> List<A> cloneAndClear(Collection<A> l) {
  return cloneAndClearList(l);
}




static JPanel jSection(Component c) {
  return jSection("", c);
}

static 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 JPanel jSection(String title) {
  return jSection(title, jpanel());
}


static JPanel jSection(LiveValue<?> lv, Component c) {
  return jLiveValueSection(lv, c);
}


static JScrollPane jscroll_copyBackground(Component c) {
  return setScrollPaneBackground(getBackground(c), jscroll(c));
}


static JFastLogView_noWrap jFastLogView_noWrap() {
  return jFastLogView_noWrap("");
}

static JFastLogView_noWrap jFastLogView_noWrap(String text) {
  return withTypeWriterFont(swingNu(JFastLogView_noWrap.class, text));
}


static String getPrintLog() {
  return str(print_log);
}


static <A extends JComponent> A componentPopupMenuItem(A c, String name, Runnable 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 void componentPopupMenuItem(JComponent c, 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 void dm_clearModulePrintLog() {
  clearStringBuffer_gen(dm_current_mandatory()._actualPrintLog());
}


static <A extends JComponent> A awtEvery(A component, long delay, Object r) {
  swingEvery(component, delay, r);
  return component;
}

static <A extends JComponent> A awtEvery(long delay, A component, Runnable r) {
  return awtEvery(component, delay, delay, (Object) r);
}

static <A extends JComponent> A awtEvery(A component, long delay, Runnable r) { return awtEvery(component, delay, delay, r); }
static <A extends JComponent> A awtEvery(A component, long delay, long firstDelay, Runnable r) {
  return awtEvery(component, delay, firstDelay, (Object) r);
}

static <A extends JComponent> A awtEvery(A component, long delay, long firstDelay, Object r) {
  swingEvery(component, delay, firstDelay, r);
  return component;
}

static void awtEvery(RootPaneContainer frame, long delay, Object r) {
  swingEvery(frame, delay, r);
}

static <A extends JComponent> A awtEvery(A component, double firstDelaySeconds, double delaySeconds, Object r) {
  return awtEvery(component, toMS(firstDelaySeconds), toMS(delaySeconds), r);
}

static <A extends JComponent> A awtEvery(A component, double delaySeconds, Object r) {
  return awtEvery(component, toMS(delaySeconds), r);
}


static boolean scrollAllTheWayDown_bruteForce = true;

static <A extends JComponent> A scrollAllTheWayDown(A c) {
  if (c != null) { swing(() -> { 
    int h = c.getHeight()-1;
    if (scrollAllTheWayDown_bruteForce) h = max(h, 100000);
    c.scrollRectToVisible(new Rectangle(0, h, 1, 1));
  }); }
  return c;
}


// independent timer
static void awtLater(int delay, final Object r) {
  swingLater(delay, r);
}

static void awtLater(int delay, Runnable r) {
  swingLater(delay, r);
}

static void awtLater(Object r) {
  swingLater(r);
}

static void awtLater(double delaySeconds, Runnable r) {
  swingLater(toMS(delaySeconds), r);
}

// dependent timer (runs only when component is visible)
static void awtLater(JComponent component, int delay, Object r) {
  installTimer(component, r, delay, delay, false);
}

static void awtLater(JFrame frame, int delay, Object r) {
  awtLater(frame.getRootPane(), delay, r);
}


static StringBuffer liveLocalPrintLog_realMC(Object o) {
  Object realMC = getMainClass(o);
  if (realMC != mc())
    return (StringBuffer) getOpt(realMC, "local_log");
  return liveLocalPrintLog();
}


static Set emptySet() {
  return new HashSet();
}


static <A, B> Map.Entry<A, B> firstEntry(Map<A, B> map) {
  return empty(map) ? null : first(map.entrySet());
}


static <A, B> A firstKey(Map<A, B> map) {
  return first(keys(map));
}


static <A, B> A firstKey(IMultiMap<A, B> map) {
  return map == null ? null : first(map.keySet());
}



static <A, B> MultiSetMap<A, B> treeMultiSetMap() {
  return new MultiSetMap(true);
}

static <A, B> MultiSetMap<A, B> treeMultiSetMap(Comparator<A> comparator) {
  return new MultiSetMap(new TreeMap<A, Set<B>>(comparator));
}


static <A, B> B firstValue(Map<A, B> map) {
  return first(values(map));
}


static <A, B> B firstValue(MultiSetMap<A, B> map) {
  return map == null ? null : first(firstValue(map.data));
}



static <A, B> B firstValue(MultiMap<A, B> map) {
  return map == null ? null : first(firstValue(map.data));
}





static String formatLocalDateWithSeconds(long time) {
  return localDateWithSeconds(time);
}



static String formatLocalDateWithSeconds() {
  return localDateWithSeconds();
}


static BigInteger plus(BigInteger a, BigInteger b) {
  return a.add(b);
}

static BigInteger plus(BigInteger a, long b) {
  return a.add(bigint(b));
}

static long plus(long a, long b) { return a+b; }
static int plus(int a, int b) { return a+b; }
static float plus(float a, float b) { return a+b; }
static double plus(double a, double b) { return a+b; }


static long clockTimeToSystemTime(long now) {
  return now == 0 ? 0 : now + clockToSysTimeDiff();
}


static <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 BigInteger minus(BigInteger a, BigInteger b) {
  return a.subtract(b);
}


static Complex minus(Complex c) {
  return c == null ? null : complex(-c.re(), -c.im());
}



  static int minus(int a, int b) {
    return a-b;
  }
  
  static int minus(int a) {
    return -a;
  }


  static double minus(double a, double b) {
    return a-b;
  }
  
  static double minus(double a) {
    return -a;
  }


  static long minus(long a, long b) {
    return a-b;
  }
  
  static long minus(long a) {
    return -a;
  }




static 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 java.util.Timer doLater_daemon(double delaySeconds, final Object r) {
  return doLater_daemon(toMS(delaySeconds), r);
}



static void cancelTimer(javax.swing.Timer timer) {
  if (timer != null) timer.stop();
}


static void cancelTimer(java.util.Timer timer) {
  if (timer != null) timer.cancel();
}

static 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) { pcallFail(__e); }}
}


static <A> List<A> syncList() {
  return synchroList();
}



static <A> List<A> syncList(List<A> l) {
  return synchroList(l);
}


static 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 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 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 int idiv_ceil(int a, int b) {
  return (a+b-1)/b;
}

static int idiv_ceil(long a, long b) {
  return toInt_checked((a+b-1)/b);
}




static boolean setText_opt = true; // optimize by calling getText first

static <A extends JTextComponent> A setText(A c, Object text) {
  setText((JComponent) c, text);
  return c;
}

static <A extends JComboBox> A setText(final A c, Object text) {
  // only for editable combo boxes at this point
  final String s = strUnnull(text);
  { swing(() -> { 
    c.getEditor().setItem(s);
  }); }
  return c;
}

static void setText(JLabel c, Object text) {
  setText((JComponent) c, text);
}

static JButton setText(JButton c, Object text) {
  setText((JComponent) c, jlabel_textAsHTML_center_ifNeeded(strUnnull(text)));
  return c;
}

static <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 <A> List<A> asSyncList(Iterable<A> l) {
  return asSynchroList(l);
}


static <A extends Component> A _revalidate(A c) {
  return revalidate(c);
}

static void _revalidate(JFrame f) {
  revalidate(f);
}

static void _revalidate(JInternalFrame f) {
  revalidate(f);
}


static boolean endsWithNewLine(String s) {
  return endsWith(s, "\n");
}



static 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 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 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();"; }});
}

// returns the contents of text field for editable combo box
static String getText(final JComboBox cb) {
  if (cb == null) return null;
  if (isEditableComboBox(cb))
    return unnull((String) cb.getEditor().getItem());
  else
    return strOrNull(cb.getSelectedItem());
}





static String lines_rtrimIf(boolean rtrim, List<String> lines) {
  return rtrim ? lines_rtrim(lines) : lines(lines);
}


static int seconds() {
  return seconds(java.util.Calendar.getInstance());
}

static int seconds(java.util.Calendar c) {
  return c.get(java.util.Calendar.SECOND);
}




static Flag dm_initErrorHandling_flag = new Flag();

static void dm_initErrorHandling() {
  raiseFlagAndDo(dm_initErrorHandling_flag, new Runnable() {  public void run() { try { 
    _handleException_addHandler(__1 -> dm_initErrorHandling_handler(__1));
    
    assertNull(_onRegisterThread);
    _onRegisterThread = new VF1<Thread>() { public void get(Thread t) { try { 
      Object m = dm_current_generic();
      if (m == null) printStackTrace("New thread made outside of a module");
      else if (m instanceof DynModule) ((DynModule) m).ownTimer(t);
     } catch (Exception __e) { throw rethrow(__e); } }
  public String toString() { return "O m = dm_current_generic();\r\n      if (m == null) printStackTrace(\"New thread..."; }};
    _threadInfo_makers.add(new VF1<Map>() { public void get(Map map) { try {  mapPut(map, "currentModule", dm_currentModule()) ; } catch (Exception __e) { throw rethrow(__e); } }
  public String toString() { return "mapPut(map, \"currentModule\", dm_currentModule())"; }});
    _threadInheritInfo_retrievers.add(new VF1<Map>() { public void get(Map map) { try { 
      Object mod = map.get("currentModule");
      if (mod instanceof DynModule)
        dm_current_generic_tl().set(new WeakReference((DynModule) mod));
     } catch (Exception __e) { throw rethrow(__e); } }
  public String toString() { return "O mod = map.get(\"currentModule\");\r\n      if (mod cast DynModule)\r\n        dm_..."; }});
  
} catch (Exception __e) { throw rethrow(__e); } }  public String toString() { return "_handleException_addHandler(lambda1 dm_initErrorHandling_handler);\r\n    \r\n   ..."; }});
}

static void dm_initErrorHandling_handler(Throwable e) {
  DynModule m = dm_currentModule();
  if (m == null)
    print("Weird: Error outside of module");
  else
    m.setField("_error" , persistableThrowable(e));
}




static void setMainDesktopPane(JDesktopPane desktop) {
  mainDesktopPane_value = desktop;
}


static <A> A getCreatorOpt(String field) {
  return (A) getOpt(creator(), field);
}


static <A extends Component> A possiblyInternalFrameTitle(A c, String title) {
  JInternalFrame f = getInternalFrame(c);
  if (f != null) internalFrameTitle(f, title);
  else frameTitle(getFrame(c), title);
  return c;
}

static String possiblyInternalFrameTitle(Component c) {
  JInternalFrame f = getInternalFrame(c);
  return f != null ? internalFrameTitle(f) : frameTitle(getFrame(c));
}


static void cancelTimerOrInterruptThread(Object timer) {
  if (timer instanceof Thread && !(timer instanceof AutoCloseable)) // AutoCloseable takes precedence
    interruptThread((Thread) timer);
  else
    cancelTimer(timer);
}


static <A> List<A> getAndClearList(Collection<A> l) {
  if (l == null) return emptyList();
  synchronized(collectionMutex(l)) {
    List<A> out = cloneList(l);
    l.clear();
    return out;
  }
}


static <A, B> Map<A, B> getAndClearMap(Map<A, B> map) {
  if (map == null) return emptyMap();
  synchronized(collectionMutex(map)) {
    Map<A, B> out = cloneMap(map);
    map.clear();
    return out;
  }
}


static boolean dm_isPersistentField(String field) { return dm_isPersistentField(dm_current_mandatory(), field); }
static boolean dm_isPersistentField(DynModule m, String field) {
  return m.persistOnChangedField
    && !isTransientField(m, field)
    && !isFalse(mapGet(m._persistenceInfo, field));
}


static Rect dm_getBounds(Object module) {
  return shallowCloneToClass(Rect.class, call(dm_getStem(module), "getFrameRect"));
}


static Rect dm_getBounds() {
  return dm_getBounds(dm_current_generic());
}



static boolean hasMethod_onTypes(Object o, String method, Class... argTypes) {
  return findMethod_precise_onTypes(o, method, argTypes) != null;
}


static void dm_onTopInput_q(final VF1<String> r) {
  final DynModule m = dm_current_mandatory();
  dm_onTopInput(new VF1<String>() { public void get(final String s) { try { 
    m.q().add(new Runnable() {  public void run() { try { 
    callF(r, s);
   
} catch (Exception __e) { throw rethrow(__e); } }  public String toString() { return "callF(r, s);"; }}); } catch (Exception __e) { throw rethrow(__e); } }
  public String toString() { return "switch to m.q();\r\n    callF(r, s);"; }});
}


static <A> AutoCloseable tempSetBetterThreadLocalIfNecessary_weakRef(x30_pkg.x30_util.BetterThreadLocal<WeakReference> tl, A a) {
  if (tl == null) return null;
  WeakReference prev = tl.get();
  if (eq(getWeakRef(prev), a)) return null;
  tl.set(weakRef(a));
  return new AutoCloseable() { public String toString() { return "tl.set(prev);"; } public void close() throws Exception { tl.set(prev); }};
}


static AutoCloseable combineAutoCloseables(final AutoCloseable a, final AutoCloseable b) {
  return a == null ? b : b == null ? a : new AutoCloseable() { public String toString() { return "pClose(a); pClose(b);"; } public void close() throws Exception { pClose(a); pClose(b); }};
}

static AutoCloseable combineAutoCloseables(AutoCloseable a, AutoCloseable b, AutoCloseable c, AutoCloseable... more) {
  return combineAutoCloseables(concatLists(ll(a, b, c), asList(more)));
}

static AutoCloseable combineAutoCloseables(Iterable<AutoCloseable> l) {
  return foldl(new F2<AutoCloseable, AutoCloseable, AutoCloseable>() { public AutoCloseable get(AutoCloseable a, AutoCloseable b) { try {  return combineAutoCloseables(a,b);  } catch (Exception __e) { throw rethrow(__e); } }
  public String toString() { return "combineAutoCloseables(a,b)"; }}, null, l);
}


static <A> boolean addIfNotThere(Collection<A> c, A a) {
  return setAdd(c, a);
}


static <A extends JSpinner> A onChange(A spinner, Object r) {
  return onChange(spinner, toRunnable(r));
}

static <A extends JSpinner> A onChange(A spinner, Runnable r) {
  if (r != null)
    { swing(() -> {  spinner.addChangeListener(changeListener(r)); }); }
  return spinner;
}

static <A extends AbstractButton> A onChange(A b, Runnable r) {
  { swing(() -> {  b.addItemListener(itemListener(r)); }); }
  return b;
}

static void onChange(JTextComponent tc, Runnable r) {
  onUpdate(tc, r);
}

static <A extends JSlider> A onChange(A slider, Runnable r) {
  { swing(() -> {  slider.addChangeListener(changeListener(r)); }); }
  return slider;
}

static <A> JComboBox<A> onChange(JComboBox<A> cb, ChangeTriggerable r) {
  return onChange(cb, new ChangeTrigger(r));
}

static <A> JComboBox<A> onChange(JComboBox<A> cb, IVF1<A> f) {
  if (f != null) addActionListener(cb, () -> f.get(getSelectedItem_typed(cb)));
  return cb;
}

// Note: JComboBox also supports addActionListener.
// Not sure if that would help us any.
static JComboBox onChange(JComboBox cb, Runnable r) {
  if (isEditableComboBox(cb))
    onChange(textFieldFromComboBox(cb), r);
  else
    onSelectedItem(cb, runnableToIVF1(r));
  return cb;
}

static <A extends JTabbedPane> A onChange(A tabs, Runnable r) {
  { swing(() -> {  tabs.addChangeListener(changeListener(r)); }); }
  return tabs;
}

static <A extends JColorChooser> A onChange(Runnable r, A cc) {
  if (cc != null && r != null) { swing(() -> { 
    cc.getSelectionModel().addChangeListener(changeListener(r));
  }); }
  return cc;
}

static <A extends IHasChangeListeners> A onChange(A a, ChangeTriggerable b) {
  if (a != null && b != null) a.onChange(new ChangeTrigger(b));
  return a;
}

static <A extends IHasChangeListeners> A onChange(A a, Updateable b) {
  if (a != null && b != null) a.onChange(new UpdateTrigger(b));
  return a;
}

static <A extends IHasChangeListeners> A onChange(A a, Runnable r) {
  if (a != null && r != null) a.onChange(r);
  return a;
}


// action = runnable or method name (old)
static void onUpdateAndNow(JComponent c, final Object r) {
  onUpdate(c, r);
  callF(r);
}

static void onUpdateAndNow(JTextComponent c, IVF1<String> r) { swing(() -> { 
  if (c == null) return;
  onUpdate(c, r);
  callF(r, c.getText());
}); }

static void onUpdateAndNow(List<? extends JComponent> l, Object r) {
  for (JComponent c : l)
    onUpdate(c, r);
  callF(r);
}


// action = runnable or method name
static void onChangeAndNow(JComponent c, Object r) {
  onUpdateAndNow(c, r);
}

static void onChangeAndNow(List<? extends JComponent> l, Object r) {
  onUpdateAndNow(l, r);
}

static void onChangeAndNow(JTextComponent c, IVF1<String> r) {
  onUpdateAndNow(c, r);
}

static <A> JComboBox<A> onChangeAndNow(JComboBox<A> cb, IVF1<A> f) {
  onChange(cb, f);
  { if (f != null) f.get(getSelectedItem_typed(cb)); }
  return cb;
}

static <A extends JTabbedPane> A onChangeAndNow(A tabs, Runnable r) {
  if (r != null) {
    onChange(tabs, r);
    r.run();
  }
  return tabs;
}

static JSlider onChangeAndNow(JSlider s, Runnable f) {
  if (s != null && f != null) {
    onChange(s, f);
    f.run();
  }
  return s;
}



static void onUpdate(JComponent c, Runnable r) {
  onUpdate(c, (Object) r);
}

static void onUpdate(JTextComponent c, IVF1<String> r) {
  if (c == null || r == null) return;
  c.getDocument().addDocumentListener(runnableToDocumentListener(() -> r.get(c.getText())));
}

// legacy signature
static void onUpdate(JComponent c, Object r) {
  if (c instanceof JTextComponent)
    ((JTextComponent) c).getDocument().addDocumentListener(runnableToDocumentListener(toRunnable(r)));
  else if (c instanceof ItemSelectable) // JCheckBox and others
    ((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 void onUpdate(List<? extends JComponent> l, Object r) {
  for (JComponent c : l)
    onUpdate(c, r);
}


static void zeroAllFieldsOfTypeExcept(Object o, Class type, String... exceptions) {
  zeroAllFieldsOfTypeExcept(o, type, asSet(exceptions));
}

static void zeroAllFieldsOfTypeExcept(Object o, Class type, Collection<String> exceptions) {
  Set<String> set = asSet(exceptions);
  for (String field : allFields(o))
    if (!set.contains(field) && instanceOf(getOpt(o, field), type))
      set(o, field, null);
}


static List<AbstractAction> paramsToAbstractActions(Object... params) {
  List<AbstractAction> l = new ArrayList();
  for (int i = 0; i+1 < l(params); i += 2) {
    String text =  (String) (params[i]);
    Runnable action =  (Runnable) (params[i+1]);
    if (nempty(text))
      l.add(abstractAction(text, action));
  }
  return l;
}


static void internalFramePopupMenuFromActions_threaded(Container f, List<AbstractAction> actions) {
  if (!(f instanceof JInternalFrame)) return;
  for (final AbstractAction a : unnull(actions))
    if (a != null)
      internalFramePopupMenuItem(((JInternalFrame) f), str(a.getValue(Action.NAME)), runnableThread(new Runnable() {  public void run() { try {  callAction(a) ;
} catch (Exception __e) { throw rethrow(__e); } }  public String toString() { return "callAction(a)"; }}));
}


static <A> LinkedHashSet<A> asLinkedHashSet(A[] array) {
  LinkedHashSet<A> set = new LinkedHashSet();
  for (A o : array)
    if (o != null)
      set.add(o);
  return set;
}

static <A> LinkedHashSet<A> asLinkedHashSet(Collection<A> l) {
  if (l instanceof LinkedHashSet) return (LinkedHashSet) l;
  LinkedHashSet<A> set = new LinkedHashSet();
  for (A o : l)
    if (o != null)
      set.add(o);
  return set;
}


static Map<Class, Set<String>> allFields_cache = weakHashMap();

static 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 Class fieldType(Object o, String field) {
  Field f = getField(o, field);
  return f == null ? null : f.getType();
}


static void dm_boolFieldMenuItem(Container frame, final String field, final Object... __) {
  final DynModule m = dm_current_mandatory();
  final String humanized = humanizeFormLabel(field);
  internalFrameTitlePopupMenu(((JInternalFrame) frame), new VF1<JPopupMenu>() { public void get(JPopupMenu menu) { try { 
    menu.add(jCheckBoxMenuItem(humanized, (boolean) _get(m, field), new VF1<Boolean>() { public void get(Boolean b) { try { 
      m.setField(field, b);
      callF(optPar(__, "onSet"));
     } catch (Exception __e) { throw rethrow(__e); } }
  public String toString() { return "m.setField(field, b);\r\n      callF(optPar(_, 'onSet));"; }}));
   } catch (Exception __e) { throw rethrow(__e); } }
  public String toString() { return "menu.add(jCheckBoxMenuItem(humanized, (bool) _get(m, field), voidfunc(bool b)..."; }});
}


static void dm_intFieldMenuItem(Container frame, final String field, final Object... __) {
  final DynModule m = dm_current_mandatory();
  final String humanized = humanizeFormLabel(field);
  internalFramePopupMenuItem(((JInternalFrame) frame), humanizeFormLabel(field) + "...", new Runnable() {  public void run() { try { 
    final JTextField tf = jtextfield(get(m, field));
    showFormTitled(or2(stringOptPar(__, "formTitle"), "Set " + humanized),
      humanized + ":", tf, new Runnable() {  public void run() { try { 
        m.setField(field, parseInt(gtt(tf)));
        callF(optPar(__, "onSet"));
      
} catch (Exception __e) { throw rethrow(__e); } }  public String toString() { return "m.setField(field, parseInt(gtt(tf)));\r\n        callF(optPar(__, \"onSet\"));"; }});
  
} catch (Exception __e) { throw rethrow(__e); } }  public String toString() { return "final JTextField tf = jtextfield(get(m, field));\r\n    showFormTitled(or2(stri..."; }});
}


static void dm_longFieldMenuItem(Container frame, final String field, final Object... __) {
  final DynModule m = dm_current_mandatory();
  final String humanized = humanizeFormLabel(field);
  internalFramePopupMenuItem(((JInternalFrame) frame), humanizeFormLabel(field) + "...", new Runnable() {  public void run() { try { 
    final JTextField tf = jtextfield(get(m, field));
    showFormTitled(or2(stringOptPar(__, "formTitle"), "Set " + humanized),
      humanized + ":", tf, new Runnable() {  public void run() { try { 
        m.setField(field, parseLong(gtt(tf)));
        callF(optPar(__, "onSet"));
      
} catch (Exception __e) { throw rethrow(__e); } }  public String toString() { return "m.setField(field, parseLong(gtt(tf)));\r\n        callF(optPar(__, \"onSet\"));"; }});
  
} catch (Exception __e) { throw rethrow(__e); } }  public String toString() { return "final JTextField tf = jtextfield(get(m, field));\r\n    showFormTitled(or2(stri..."; }});
}


static void dm_doubleFieldMenuItem(Container frame, final String field, final Object... __) {
  final DynModule m = dm_current_mandatory();
  internalFramePopupMenuItem(((JInternalFrame) frame), humanizeFormLabel(field) + "...", new Runnable() {  public void run() { try { 
     AutoCloseable __1 = m.enter(); try {
    dm_doubleFieldSetterDialog(field, __);
  
} finally { _close(__1); }} catch (Exception __e) { throw rethrow(__e); } }  public String toString() { return "temp m.enter();\r\n    dm_doubleFieldSetterDialog(field, __);"; }});
}


static void dm_floatFieldMenuItem(Container frame, String field, Object... __) {
  DynModule m = dm_current_mandatory();
  internalFramePopupMenuItem(((JInternalFrame) frame), humanizeFormLabel(field) + "...", new Runnable() {  public void run() { try { 
     AutoCloseable __1 = m.enter(); try {
    dm_floatFieldSetterDialog(field, __);
  
} finally { _close(__1); }} catch (Exception __e) { throw rethrow(__e); } }  public String toString() { return "temp m.enter();\r\n    dm_floatFieldSetterDialog(field, __);"; }});
}


static void dm_stringFieldMenuItem(Container frame, final String field, final Object... __) {
  final DynModule m = dm_current_mandatory();
  internalFramePopupMenuItem(((JInternalFrame) frame), humanizeFormLabel(field) + "...", new Runnable() {  public void run() { try { 
     AutoCloseable __1 = m.enter(); try {
    dm_stringFieldDialog(field, __);
  
} finally { _close(__1); }} catch (Exception __e) { throw rethrow(__e); } }  public String toString() { return "temp m.enter();\r\n    dm_stringFieldDialog(field, __);"; }});
}


static void dm_fileFieldMenuItem(Container frame, String field, Object... __) {
  DynModule m = dm_current_mandatory();
  internalFramePopupMenuItem(((JInternalFrame) frame), humanizeFormLabel(field) + "...", new Runnable() {  public void run() { try { 
     AutoCloseable __1 = m.enter(); try {
    dm_fileFieldDialog(field, __);
  
} finally { _close(__1); }} catch (Exception __e) { throw rethrow(__e); } }  public String toString() { return "temp m.enter();\r\n    dm_fileFieldDialog(field, __);"; }});
}


static ReliableSingleThread dm_rst(Runnable r) {
  return dm_rst(dm_current_mandatory(), r);
}

static ReliableSingleThread dm_rst(DynModule mod, Runnable r) {
  return dm_rst(mod, new ReliableSingleThread(r));
}

static ReliableSingleThread dm_rst(DynModule mod, ReliableSingleThread rst) {
  rst.enter = dm_rEnter(mod);
  return rst;
}


static Q dm_startQ() {
  return dm_ownQ(startQ());
}

static Q dm_startQ(String name) {
  return dm_ownQ(startQ(name));
}


static JComponent dm_noVisualisation() {
  return setToolTip("Module has no visualization", jimage("#1101480"));
}


static String snippetTitle(String id) {
  return getSnippetTitle(id);
}

static String snippetTitle(long id) {
  return getSnippetTitle(id);
}



static Class mainClass() {
  return getMainClass();
}

static Class mainClass(Object o) {
  return getMainClass(o);
}


static <A, B> Map<A, B> mapMinus(Map<A, B> map, Object... keys) {
  if (empty(keys)) return map;
  Map<A, B> m2 = cloneMap(map);
  for (Object key : keys)
    m2.remove(key);
  return m2;
}


static <A, B> Map<A, B> mapPlus(Map<A, B> m, Object... data) {
  m = cloneMap(m);
  litmap_impl(m, data);
  return m;
}


static Set<java.util.Timer> _registerTimer_list = newWeakHashSet();

static void _registerTimer_original(java.util.Timer timer) {
  _registerTimer_list.add(timer);
}

static void cleanMeUp__registerTimer() {
  cancelTimers(getAndClearList(_registerTimer_list));
}


static DynModule dm_currentModule() {
  return optCast(DynModule.class, dm_current_generic());
}


static String assertGlobalID(String s) {
  return assertPossibleGlobalID(s);
}


static BigInteger bigint(String s) {
  return new BigInteger(s);
}

static BigInteger bigint(long l) {
  return BigInteger.valueOf(l);
}


static BigInteger mul(BigInteger a, BigInteger b) {
  return a.multiply(b);
}

static BigInteger mul(BigInteger a, long b) {
  return a.multiply(bigint(b));
}

static int mul(int a, int b) { return a*b; }
static double mul(double a, double b) { return a*b; }


static String bigintToGlobalID(BigInteger value) {
  char[] buf = new char[16];
  for (int i = 16-1; i >= 0; i--) {
    buf[i] = charPlus('a', mod(value, 26).intValue());
    value = div(value, 26);
  }
  return str(buf);
}


static Class _run(String progID, String... args) {
  Class main = hotwire(progID);
  callMain(main, args);
  return main;
}


static <A> A syncPopFirst(List<A> l) {
  if (empty(l)) return null;
  synchronized(l) {
    A a = first(l);
    l.remove(0);
    return a;
  }
}


static int inc(AtomicInteger i) {
  return incAtomicInt(i);
}

static int inc(AtomicInteger i, int delta) {
  return incAtomicInt(i, delta);
}

static long inc(AtomicLong l) {
  return incAtomicLong(l);
}

static long inc(AtomicLong l, long b) {
  return l.addAndGet(b);
}

static int inc(IntVar v) {
  synchronized(v) {
    int val = v.get() + 1;
    v.set(val);
    return val;
  }
}

static int inc(int i) { return i+1; }
static long inc(long l) { return l+1; }


static String systemHashCodeHex(Object o) {
  return intToHex(identityHashCode(o));
}


static String nEntries(long n) { return n2(n, "entry", "entries"); }
static String nEntries(Collection l) { return nEntries(l(l)); }
static String nEntries(Map map) { return nEntries(l(map)); }


static <A> List<A> syncGetAndClear(Collection<A> l) {
  return syncCloneAndClearList(l);
}


static void cancelAndInterruptThread(Thread t) {
  if (t == null) return;
  cancelThread(t);
  t.interrupt();
}




static Object _onAWTEnter_f;

static AutoCloseable _onAWTEnter() {
  return (AutoCloseable) callF(_onAWTEnter_f);
}


static JDesktopPane mainDesktopPane_value;

static JDesktopPane mainDesktopPane() {
  return mainDesktopPane_value;
}


static NanoHTTPD.Response maxCacheHeaders(NanoHTTPD.Response r) {
  r.addHeader("Pragma", "public");
  r.addHeader("Cache-Control", "public, max-age=86400");
  return r;
}


static void setTrayIconToolTip(TrayIcon trayIcon, String toolTip) {
  if (trayIcon != null) trayIcon.setToolTip(toolTip);
}


static List<String> allToString(Iterable c) {
  List<String> l = new ArrayList();
  for (Object o : unnull(c)) l.add(str(o));
  return l;
}

static List<String> allToString(Object[] c) {
  List<String> l = new ArrayList();
  for (Object o : unnull(c)) l.add(str(o));
  return l;
}


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

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

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

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



static String decimalFormatEnglish(String format, double d) {
  return decimalFormatEnglish(format).format(d);
}

static java.text.DecimalFormat decimalFormatEnglish(String format) {
  return new java.text.DecimalFormat(format, new java.text.DecimalFormatSymbols(Locale.ENGLISH));
}


static <A, B> List<B> lookupAllOpt(Map<A, B> map, Collection<A> l) {
  List<B> out = new ArrayList();
  if (l != null) for (A a : l)
    addIfNotNull(out, map.get(a));
  return out; 
}

static <A, B> List<B> lookupAllOpt(Collection<A> l, Map<A, B> map) {
  return lookupAllOpt(map, l);
}


static <A, B extends IF0<A>> List<A> getVars(Iterable<B> l) {
  return lambdaMap(__90 -> getVar(__90), l);
}


static String dropNumberPrefix(String s) {
  return dropFirst(s, indexOfNonDigit(s));
}


static void readLocally(String progID, String varNames) {
  readLocally2(mc(), progID, varNames);
}

static void readLocally(String varNames) {
  readLocally2(mc(), programID(), varNames);
}

static void readLocally2(Object obj, String varNames) {
  readLocally2(obj, programID(), varNames);
}

static int readLocally_stringLength;

static ThreadLocal<Boolean> readLocally2_allDynamic = new ThreadLocal();
static ThreadLocal readLocally2_classFinder = new ThreadLocal();

// read a string variable from standard storage
// does not overwrite variable contents if there is no file
static 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;
        //value = loadGZTextFile(structureGZFile);
         InputStream fis = new FileInputStream(structureGZFile); try {
        GZIPInputStream gis = newGZIPInputStream(fis);
        InputStreamReader reader = new InputStreamReader(gis, "UTF-8");
        BufferedReader bufferedReader = new BufferedReader(reader);
        //O o = unstructure_reader(bufferedReader);
        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 void readLocally_set(Object c, String varName, Object value) {
  Object oldValue = get(c, varName);
  if (oldValue instanceof List && !(oldValue instanceof ArrayList) && value != null) {
    // Assume it's a synchroList.
    value = synchroList((List) value);
  }
  set(c, varName, value);
}



static boolean cic(Collection<String> l, String s) {
  return containsIgnoreCase(l, s);
}


static boolean cic(Collection<Symbol> l, Symbol s) {
  return contains(l, s);
}


static boolean cic(String[] l, String s) {
  return containsIgnoreCase(l, s);
}

static boolean cic(String s, char c) {
  return containsIgnoreCase(s, c);
}

static boolean cic(String a, String b) {
  return containsIgnoreCase(a, b);
}



static String conceptsFileName() {
  return "concepts.structure.gz";
}


static String dbProgramID() {
  return getDBProgramID();
}


static String formatWithThousands(long l) {
  return formatWithThousandsSeparator(l);
}


static String plural(String s) {
  return getPlural(s);
}


static double fraction(double d) {
  return d % 1;
}


static String n_fancy2(long l, String singular, String plural) {
  return formatWithThousandsSeparator(l) + " " + trim(l == 1 ? singular : plural);
}

static String n_fancy2(Collection l, String singular, String plural) {
  return n_fancy2(l(l), singular, plural);
}

static String n_fancy2(Map m, String singular, String plural) {
  return n_fancy2(l(m), singular, plural);
}

static String n_fancy2(Object[] a, String singular, String plural) {
  return n_fancy2(l(a), singular, plural);
}


  static String n_fancy2(MultiSet ms, String singular, String plural) {
    return n_fancy2(l(ms), singular, plural);
  }



static List callF_all(Collection l, Object... args) {
  return map(l, f -> callF(f, args));
}


static File tempFileFor(File f) {
  return new File(f.getPath() + "_temp");
}


static double toM_double(long l) {
  return l/(1024*1024.0);
}


static boolean containsNewLine(String s) {
  return contains(s, '\n'); // screw \r, nobody needs it
}


public static String rtrimSpaces(String s) {
  if (s == null) return null;
  int i = s.length();
  while (i > 0 && " \t".indexOf(s.charAt(i-1)) >= 0)
    --i;
  return i < s.length() ? s.substring(0, i) : s;
}


static int year() {
  return localYear();
}

static int year(Timestamp now) {
  return localYear(toLong(now));
}

static int year(long now) {
  return localYear(now);
}

static int year(long now, TimeZone tz) {
  return parseInt(simpleDateFormat("y", tz).format(now));
}


static int month() {
  return localMonth();
}

static int month(Timestamp now) {
  return localMonth(toLong(now));
}

static int month(long now) {
  return localMonth(now);
}

static int month(long now, TimeZone tz) {
  return parseInt(simpleDateFormat("M", tz).format(now));
}


static int dayOfMonth() {
  return localDayOfMonth();
}

static int dayOfMonth(long now) {
  return localDayOfMonth(now);
}

static int dayOfMonth(long now, TimeZone tz) {
  return parseInt(simpleDateFormat("d", tz).format(now));
}


static String padLeft(String s, char c, int n) {
  return rep(c, n-l(s)) + s;
}

// default to space
static String padLeft(String s, int n) {
  return padLeft(s, ' ', n);
}


static java.util.Calendar calendarFromTime(long time, TimeZone tz) {
  java.util.Calendar c = java.util.Calendar.getInstance(tz);
  c.setTimeInMillis(time);
  return c;
}

static java.util.Calendar calendarFromTime(long time) {
  java.util.Calendar c = java.util.Calendar.getInstance();
  c.setTimeInMillis(time);
  return c;
}


// TODO: optimize to x-(x%n) in case that's the same thing
// (or x-mod(x,n)?)
static int roundDownTo(int n, int x) {
  return x/n*n;
}

static long roundDownTo(long n, long x) {
  return x/n*n;
}

static double roundDownTo(double n, double x) {
  return floor(x/n)*n;
}


static String defaultTimerName_name;

static String defaultTimerName() {
  if (defaultTimerName_name == null)
    defaultTimerName_name = "A timer by " + programID();
  return defaultTimerName_name;
}


// r may return false to cancel timer
static TimerTask smartTimerTask(Object r, java.util.Timer timer, long delay) {
  return new SmartTimerTask(r, timer, delay, _threadInfo());
}

static class SmartTimerTask extends TimerTask implements IFieldsToList{
  Object r;
  java.util.Timer timer;
  long delay;
  Object threadInfo;
  SmartTimerTask() {}
  SmartTimerTask(Object r, java.util.Timer timer, long delay, Object threadInfo) {
  this.threadInfo = threadInfo;
  this.delay = delay;
  this.timer = timer;
  this.r = r;}
  public String toString() { return shortClassName_dropNumberPrefix(this) + "(" + r + ", " + timer + ", " + delay + ", " + threadInfo + ")"; }public Object[] _fieldsToList() { return new Object[] {r, timer, delay, threadInfo}; }

  long lastRun;
  
  public void run() {
    if (!licensed())
      timer.cancel();
    else {
      _threadInheritInfo(threadInfo);
       AutoCloseable __1 = tempActivity(r); try {
      lastRun = fixTimestamp(lastRun);
      long now = now();
      if (now >= lastRun + delay*0.9) {
        lastRun = now;
        if (eq(false, pcallF(r)))
          timer.cancel();
      }
    } finally { _close(__1); }}
  }
}


static void close_pcall(AutoCloseable c) {
  if (c != null) { try { c.close(); } catch (Throwable __e) { pcallFail(__e); }}
}


static <A, B> List<A> keysList(Map<A, B> map) {
  return cloneListSynchronizingOn(keys(map), map);
}


  static <A> List<A> keysList(MultiSet<A> ms) {
    return ms == null ? null : keysList(ms.map);
  }



static <A, B> List<B> valuesList(Map<A, B> map) {
  return cloneListSynchronizingOn(values(map), map);
}


static <A, B> List<B> valuesList(MultiMap<A, B> mm) {
  return mm == null ? emptyList() : concatLists(values(mm.data));
}



static <A> void syncClear(Collection<A> c) {
  if (c != null) synchronized(collectionMutex(c)) { c.clear(); }
}

static void syncClear(Map map) {
  if (map != null) synchronized(collectionMutex(map)) { map.clear(); }
}


static 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); // so ping notices
  setOpt_raw(c, "cleaningUp_flag" , true);
}


static void innerCleanUp(Object c) {
  // call custom cleanMeUp() and cleanMeUp_*() functions
  
  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 void innerCleanUp() {
  innerCleanUp(mc());
}


static Object pcallOpt(Object o, String method, Object... args) {
  try { return callOpt(o, method, args); } catch (Throwable __e) { pcallFail(__e); }
  return null;
}


static List<Thread> registeredThreads(Object o) {
  Map<Thread, Boolean> map =  (Map<Thread, Boolean>) (getOpt(o, "_registerThread_threads"));
  if (map == null) return ll();
  map.size(); // force clean-up
  synchronized(map) { return asList(keys(map)); }
}

static List<Thread> registeredThreads() {
  _registerThread_threads.size(); // force clean-up
  return asList(keys(_registerThread_threads));
}


static void interruptThreads(Collection<Thread> threads) {
  for (Thread t : unnull(threads))
    interruptThread(t);
}

static void interruptThreads(Class mainClass) {
  interruptThreads(registeredThreads(mainClass));
}


static void retireClassLoader(ClassLoader cl) {
  try {
    if (isJavaXClassLoader(cl))
      setOptAll(cl, "retired" , true, "retiredMarker" , new DefunctClassLoader());
  } catch (Throwable __e) { pcallFail(__e); }
}



static String dynamicClassName(Object o) {
  if (o instanceof DynamicObject && ((DynamicObject) o).className != null)
    return "main$" + ((DynamicObject) o).className;
  return className(o);
}


static String loadTextFilePossiblyGZipped(String fileName) {
  return loadTextFilePossiblyGZipped(fileName, null);
}
  
static String loadTextFilePossiblyGZipped(String fileName, String defaultContents) {
  File gz = new File(fileName + ".gz");
  return gz.exists() ? loadGZTextFile(gz) : loadTextFile(fileName, defaultContents);
}

static String loadTextFilePossiblyGZipped(File fileName) {
  return loadTextFilePossiblyGZipped(fileName, null);
}

static String loadTextFilePossiblyGZipped(File fileName, String defaultContents) {
  return loadTextFilePossiblyGZipped(fileName.getPath(), defaultContents);
}



static boolean isUnstructuring() {
  return isTrue(getTL(dynamicObjectIsLoading_threadLocal()));
}


static String fulltag(String tag) {
  return hfulltag(tag);
}



static String fulltag(String tag, Object contents, Object... params) {
  return hfulltag(tag, contents, params);
}


static Object getOptMC(String field) {
  return getOpt(mc(), field);
}


// o is either a map already (string->object) or an arbitrary object,
// in which case its fields are converted into a map.
static Map<String, Object> objectToMap(Object o) { try {
  if (o instanceof Map) return (Map) o;
  if (o == null) return null;
  
  TreeMap<String, Object> map = new TreeMap();
  Class c = o.getClass();
  while (c != Object.class) {
    Field[] fields = c.getDeclaredFields();
    for (final Field field : fields) {
      if ((field.getModifiers() & Modifier.STATIC) != 0)
        continue;
      field.setAccessible(true);
      final Object value = field.get(o);
      if (value != null)
        map.put(field.getName(), value);
    }
    c = c.getSuperclass();
  }
  
  // XXX NEW - hopefully this doesn't break anything
  if (o instanceof DynamicObject)
    putAll(map, ((DynamicObject) o).fieldValues);

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

// same for a collection (convert each element)
static List<Map<String, Object>> objectToMap(Iterable l) {
  if (l == null) return null;
  List x = new ArrayList();
  for (Object o : l)
    x.add(objectToMap(o));
  return x;
}


static double positiveInfinity() {
  return Double.POSITIVE_INFINITY;
}


static <A> TreeMap<Object, A> generalizedCIMap() {
  return new TreeMap(generalizedCIComparator());
}


static String regexpExtractIC(String pat, String s) {
  if (s == null) return null;
  Matcher m = regexpMatcherIC(pat, s);
  return m.find() ? m.group() : null;
}


static String domainName() {
  Object session = call(getMainBot(), "getSession");
  Map headers =  (Map) (call(session, "getHeaders"));
  String host =  (String) (headers.get("host"));
  if (host == null) return null;
  return dropFrom(host, ":");
}


// TODO: umlaut domains
static boolean isSimpleDomainName(String s) {
  return regexpMatchesIC("[a-z0-9\\-]+\\.[a-z]+", s);
}


static Map jsonDecodeMap(String s) {
  Object o = jsonDecode(s);
  if (o instanceof List && empty((List) o))
    return new HashMap();
  if (o instanceof Map)
    return (Map) o;
  else
    throw fail("Not a JSON map: " + s);
}


static byte[] md5AsByteArray(byte[] data) { try {
  return MessageDigest.getInstance("MD5").digest(data);
} catch (Exception __e) { throw rethrow(__e); } }


static boolean md5OfFile_verbose = false;

static String md5OfFile(String path) {
  return md5OfFile(newFile(path));
}

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


// first parameter can be Concepts
static void indexConceptFields(Object... params) {
  int i = 0;
  Concepts concepts;
  if (first(params) instanceof Concepts) {
    concepts = (Concepts) first(params);
    ++i;
  } else concepts = db_mainConcepts();
  for (; i < l(params); i += 2)
    indexConceptField(concepts, (Class) params[i], (String) params[i+1]);
}


static void dm_reloadOnFieldChange(String... fields) {
  for (String field : unnullForIteration(fields))
    dm_onFieldChange(field, new Runnable() {  public void run() { try {  dm_reloadModule(); 
} catch (Exception __e) { throw rethrow(__e); } }  public String toString() { return "dm_reloadModule();"; }});
}


static char[] getChars(String s) {
  return asChars(s);
}


static List<File> sortByFileName(List<File> l) {
  return sortFilesByName(l);
}


static List<File> listDirsContainingFileNamed(File dir, String fileName) {
  return filter(listDirs(dir), d -> isFile(newFile(d, fileName)));
}


static LinkedHashMap mapToOrderedMap(Object f, Iterable l) {
  LinkedHashMap map = new LinkedHashMap();
  for (Object o : unnullForIteration(l)) {
    Pair p =  (Pair) (callF(f, o));
    map.put(p.a, p.b);
  }
  return map;
}

static <A, B, C> LinkedHashMap<B, C> mapToOrderedMap(IF1<A, Pair<B, C>> f, Iterable<A> l) {
  LinkedHashMap<B, C> map = new LinkedHashMap();
  for (A o : unnullForIteration(l)) {
    Pair<B, C> p = callF(f, o);
    map.put(p.a, p.b);
  }
  return map;
}

static <A, B, C> LinkedHashMap<B, C> mapToOrderedMap(Iterable<A> l, IF1<A, Pair<B, C>> f) {
  return mapToOrderedMap(f, l);
}




static KeyManager keyManagerFromKeyStore(File keystoreFile, char[] passphrase) { try {
  KeyStore keystore = keyStoreFromFile(keystoreFile, passphrase);
  KeyManagerFactory keyManagerFactory = KeyManagerFactory.getInstance(KeyManagerFactory.getDefaultAlgorithm());
  keyManagerFactory.init(keystore, passphrase);
  return getSingleton(keyManagerFactory.getKeyManagers());
} catch (Exception __e) { throw rethrow(__e); } }


static File anyKeyStore() {
  for (File dir : listDirs(javaxSecretDir())) {
    File f = newFile(dir, "keystore.p12");
    if (fileExists(f))
      return f;
  }
  return null;
}




static KeyStore keyStoreFromFile(File keystoreFile, char[] passphrase) { try {
  KeyStore keystore = KeyStore.getInstance(KeyStore.getDefaultType());
   InputStream keystoreStream = new FileInputStream(keystoreFile); try {
  keystore.load(keystoreStream, passphrase);
  return keystore;
} finally { _close(keystoreStream); }} catch (Exception __e) { throw rethrow(__e); } }


static void dm_ownTimer(Object resource, Object closerHelper) {
  call(dm_current_generic(), "ownTimer", resource, closerHelper);
}

static <A> A dm_ownTimer(A resource) {
  call(dm_current_generic(), "ownTimer", resource);
  return resource;
}

static <A> void dm_ownTimer(IVF1<A> closerHelper, A resource) {
  dm_ownTimer(resource, closerHelper);
}


static F0<AutoCloseable> dm_rEnter() { return dm_rEnter(dm_current()); }
static F0<AutoCloseable> dm_rEnter(DynModule mod) {
  return mod == null ? null : new F0<AutoCloseable>() { public AutoCloseable get() { try {  return mod.enter();  } catch (Exception __e) { throw rethrow(__e); } }
  public String toString() { return "return mod.enter();"; }};
}

static Runnable dm_rEnter(Runnable r) { return dm_rEnter(dm_current(), r); }
static Runnable dm_rEnter(DynModule mod, Runnable r) {
  return mod == null || r == null ? r : new Runnable() {  public void run() { try {   AutoCloseable __1 = mod.enter(); try { r.run(); 
} finally { _close(__1); }} catch (Exception __e) { throw rethrow(__e); } }  public String toString() { return "temp mod.enter(); r.run();"; }};
}


static Set<AutoCloseable> _registerAutoCloseable_set = synchroHashSet();

static void _registerAutoCloseable(AutoCloseable c) {
  addIfNotNull(_registerAutoCloseable_set, c);
}

static void cleanMeUp__registerAutoCloseable() {
  closeAutoCloseables(getAndClearList(_registerAutoCloseable_set));
}


static File mkdirs(File dir) {
  if (dir != null)
    dir.mkdirs();
  return dir;
}

static File mkdirs(String dir) {
  return mkdirs(newFile(dir));
}


static boolean fileNameIs(File f, String name) {
  return eq(fileName(f), name);
}


static double toSeconds(long ms) {
  return ms/1000.0;
}

static String toSeconds(long ms, int digits) {
  return formatDouble(toSeconds(ms), digits);
}

static double toSeconds(double ms) {
  return ms/1000.0;
}

static String toSeconds(double ms, int digits) {
  return formatDouble(toSeconds(ms), digits);
}


static <A extends Concept> Collection<A> findConceptsWhere(Class<A> c, Object... params) {
  return findConceptsWhere(db_mainConcepts(), c, params);
}

static Collection<Concept> findConceptsWhere(String c, Object... params) {
  return findConceptsWhere(db_mainConcepts(), c, params);
}

static <A extends Concept> Collection<A> findConceptsWhere(Concepts concepts, Class<A> c, Object... params) {
  ping();
  params = expandParams(c, params);
  
  // indexed
  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;
      }
    }
    
  // table scan
  return filterConcepts(concepts.list(c), params);
}

static Collection<Concept> findConceptsWhere(Concepts concepts, String c, Object... params) {
  return filterConcepts(concepts.list(c), params);
}


static boolean dm_moduleIsStarting(Object moduleOrID) {
  return isTrue(getOpt(dm_getStem(moduleOrID), "starting"));
}


static boolean dm_moduleIsReloading(Object mod) {
  Object stem = dm_stem(mod);
  return stem != null && contains((Set) dm_getOSOpt("modulesBeingReloaded"), stem);
}


static <A> A dm_callModuleOpt(Object moduleOrID, String method, Object... args) {
  Object mod = dm_getModule(moduleOrID);
  if (mod == null) return null;
   AutoCloseable __1 = dm_enter(mod); try {
  return (A) callOpt_withVarargs(mod, method, args);
} finally { _close(__1); }}


static boolean dm_moduleIsStarted(Object moduleOrID) {
  return isTrue(get(dm_getStem(moduleOrID), "started"));
}


static Object mainBot() {
  return getMainBot();
}


static List<Method> singleArgumentMethods(Iterable<Method> l) {
  return filter(l, m -> m.getParameterCount() == 1);
}


static List<Method> findMethodsNamed_nonSynthetic(Object o, String methodName) {
  return lambdaFilter(__91 -> isNonSynthetic(__91), findMethodsNamed(o, methodName));
}

static List<Method> findMethodsNamed_nonSynthetic(String methodName, Object o) {
  return findMethodsNamed_nonSynthetic(o, methodName);
}


static Class firstMethodArgumentType(Method m) {
  return m == null ? null : first(m.getParameterTypes());
}


static boolean isInterface(Class c) {
  return c != null && c.isInterface();
}


static void internalFrameTitlePopupMenuItem(JInternalFrame f, final String name, final Object action) {
  internalFrameTitlePopupMenu(f, 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)"; }});
}


static IMeta toIMeta(Object o) {
  return initIMeta(o);
}


static Map makeObjectMetaMap() {
  //ret synchroLinkedHashMap();
  return new CompactHashMap();
}


static IAutoCloseableF0 tempMetaMutex(IMeta o) {
  return o == null ? null : o._tempMetaMutex();
}


static <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 File makeTempDir() {
    return (File) call(getJavaX(), "TempDirMaker_make");
  }


static String nohup_sanitize(String s) {
  return empty(s) ? s : takeFirst(50, s.replaceAll("[^.a-zA-Z0-9\\-_]", ""));
}



static  IF0<Boolean> shouldKeepTempFiles;
static boolean shouldKeepTempFiles() { return shouldKeepTempFiles != null ? shouldKeepTempFiles.get() : shouldKeepTempFiles_base(); }
final static boolean shouldKeepTempFiles_fallback(IF0<Boolean> _f) { return _f != null ? _f.get() : shouldKeepTempFiles_base(); }
static boolean shouldKeepTempFiles_base() {
  return false;
}


static String pad(Object s, int l) {
  return pad(s, l, ' ');
}

static String pad(Object s, int l, char c) {
  String _s = str(s);
  if (lengthOfString(_s) >= l) return _s;
  return rep(c, l-lengthOfString(_s)) + _s;
}

static String pad(int l, Object s) {
  return pad(s, l);
}


static <A> A printIndent(A o) {
  print(indentx(str(o)));
  return o;
}

static <A> A printIndent(String indent, A o) {
  print(indentx(indent, str(o)));
  return o;
}

static void printIndent(int indent, Object o) {
  print(indentx(indent, str(o)));
}


static <A, B> int lKeys(MultiMap<A, B> mm) {
  return mm == null ? 0 : mm.keysSize();
}


static File loadBinarySnippet(String snippetID) {
  
  IResourceLoader rl = vm_getResourceLoader();
  if (rl != null)
    return rl.loadLibrary(snippetID);
  
  
  return loadBinarySnippet_noResourceLoader(snippetID);
}
  
static 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 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 String x30JarServerURL() {
  return "https://botcompany.de:9898/x30.jar";
}


static ThreadLocal<Map<String, List<String>>> loadBinaryPage_responseHeaders = new ThreadLocal();
static ThreadLocal<Map<String, String>> loadBinaryPage_extraHeaders = new ThreadLocal();

static byte[] loadBinaryPage(String url) { try {
  print("Loading " + url);
  return loadBinaryPage(loadPage_openConnection(new URL(url)));
} catch (Exception __e) { throw rethrow(__e); } }

static 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 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/*Long*/(); } 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); } }



/** writes safely (to temp file, then rename) */
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";
  try (FileOutputStream fileOutputStream = newFileOutputStream(tempFileName)) {
    fileOutputStream.write(contents);
  }
  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 byte[] saveBinaryFile(File fileName, byte[] contents) {
  return saveBinaryFile(fileName.getPath(), contents);
}


static int hashMap_internalHash(Object key) {
  int h;
  return (key == null) ? 0 : (h = key.hashCode()) ^ (h >>> 16);
}


static String hfulltag(String tag) {
  return hfulltag(tag, "");
}

static String hfulltag(String tag, Object contents, Object... params) {
  return hopeningTag(tag, params) + str(contents) + "</" + tag + ">";
}


static List<String> notStartingWithIC(Collection<String> l, final String prefix) {
  return filter(unnull(l) , new F1<String, Boolean>() { public Boolean get(String s) { try {  return !startsWithIC(s, prefix);  } catch (Exception __e) { throw rethrow(__e); } }
  public String toString() { return "!startsWithIC(s, prefix)"; }});
}

static List<String> notStartingWithIC(String prefix, Collection<String> l) {
  return notStartingWithIC(l, prefix);
}


static <A> A printQuote(A a) { return printQuote("", a); }
static <A> A printQuote(String prefix, A a) {
  print(prefix, quote(a));
  return a;
}


static <A> A _get(List<A> l, int idx) {
  return l != null && idx >= 0 && idx < l(l) ? l.get(idx) : null;
}

static Object _get(Object o, String field) {
  return get(o, field);
}

static Object _get(String field, Object o) {
  return get(o, field);
}
static <A> A _get(A[] l, int idx) {
  return idx >= 0 && idx < l(l) ? l[idx] : null;
}


static MouseListener findComponentPopupMenuListener_gen(final JComponent c) {
  return c == null ? null : swing(() ->
    firstWithClassShortNamed("componentPopupMenu_Adapter", c.getMouseListeners())
  );
}


static boolean internalFrameActive(Component c) {
  final JInternalFrame f = getInternalFrame(c);
  return f != null && swing(new F0<Boolean>() { public Boolean get() { try {  return f.isSelected();  } catch (Exception __e) { throw rethrow(__e); } }
  public String toString() { return "return f.isSelected();"; }});
}


static String str_nullIfEmpty(Object o) {
  return nullIfEmpty(strOrNull(o));
}


static char charAt(String s, int i) {
  return s != null && i >= 0 && i < s.length() ? s.charAt(i) : '\0';
}


static double msToSeconds(long ms) {
  return toSeconds(ms);
}

static double msToSeconds(double ms) {
  return toSeconds(ms);
}


static long fileModificationTime(File f) {
  return f == null ? 0 : f.lastModified();
}


static <A> A vmBus_timerStarted(A timer) {
  vmBus_send("timerStarted", timer, costCenter());
  return timer;
}


static void closeRandomAccessFile(RandomAccessFile f) {
  if (f != null) try {
    f.close();
    callJavaX("dropIO", f);
  } catch (Throwable e) {
    printStackTrace(e);
  }
}


static 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 Random getRandomizer(Random r) {
  return r != null ? r : defaultRandomGenerator();
}


static <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 char oneOf(String s) {
  return empty(s) ? '?' : s.charAt(random(l(s)));
}

static <A> A oneOf(A... l) {
  return oneOf(asList(l));
}


static <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 <A, B> Pair<A, B> entryToPair(Map.Entry<A, B> e) {
  return mapEntryToPair(e);
}


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


static <A extends Concept> A registerConcept(A c) { return registerConcept(db_mainConcepts(), c); }
static <A extends Concept> A registerConcept(Concepts cc, A c) {
  { if (cc != null) cc.register(c); }
  return c;
}


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

static <A> ArrayList<A> cloneList_noSync(Collection<A> l) {
  if (l == null) return new ArrayList();
  return new ArrayList<A>(l);
}


// f: func -> A (stream ends when f returns null)
static <A> IterableIterator<A> iteratorFromFunction(final Object f) {
  class IFF extends IterableIterator<A> {
    A a;
    boolean done = false;
    
    public boolean hasNext() {
      getNext();
      return !done;
    }
    
    public A next() {
      getNext();
      if (done) throw fail();
      A _a = a;
      a = null;
      return _a;
    }
    
    void getNext() {
      if (done || a != null) return;
      a = (A) callF(f);
      done = a == null;
    }
  };
  return new IFF();
}

// optimized version for F0 argument

static <A> IterableIterator<A> iteratorFromFunction(F0<A> f) {
  return iteratorFromFunction_f0(f);
}


static <A> IterableIterator<A> iteratorFromFunction(IF0<A> f) {
  return iteratorFromFunction_if0(f);
}


// iterate safely (& quickly) in the face of concurrent modifications
static <A, B> IterableIterator<B> concurrentlyIterateValues(NavigableMap<A, B> map) {
  return concurrentlyIterateValues(map, map);
}

static <A, B> IterableIterator<B> concurrentlyIterateValues(final NavigableMap<A, B> map, Object mutex) {
  return iteratorFromFunction(new F0<B>() {
    Iterator<A> it = keys(map).iterator();
    A key;
    
    B get() {
      synchronized(mutex) {
        try {
          if (!it.hasNext()) return null;
          return map.get(key = it.next());
        } catch (ConcurrentModificationException e) {
          print("Re-iterating");
          it = map.tailMap(key, false).keySet().iterator();
          if (!it.hasNext()) return null;
          return map.get(key = it.next()); // Can't throw another exception
        }
      }
    }
  });
}


static <A, B> Map<A, List<B>> multiMapToMap(MultiMap<A, B> m) {
  return m == null ? null : m.data;
}


static <A, B extends Collection<A>> B addAllAndReturnCollection(B c, Collection<A> b) {
  if (c != null && b != null) c.addAll(b);
  return c;
}

static <A, B extends Collection<A>> B addAllAndReturnCollection(B c, A... b) {
  addAll(c, b);
  return c;
}



static <A> MultiMap<String, A> caseInsensitiveMultiMap() {
  MultiMap<String, A> mm = new MultiMap();
  mm.data = caseInsensitiveMap();
  return mm;
}


static Thread newDaemonThread(Object r) {
  Thread t = newThread(r);
  t.setDaemon(true);
  return t;
}

static Thread newDaemonThread(Object r, String name) {
  Thread t = newThread(r, name);
  t.setDaemon(true);
  return t;
}

static Thread newDaemonThread(String name, Object r) {
  return newDaemonThread(r, name);
}


static IterableIterator<String> linesIterator(String s) {
  return lines_iterator(s);
}

static CloseableIterableIterator<String> linesIterator(File f) {
  return linesFromFile(f);
}


static void joinThread(Thread t) { try {
  if (t != null) t.join();
} catch (Exception __e) { throw rethrow(__e); } }

static void joinThread(Thread t, long ms) { try {
  if (t != null) t.join(ms);
} catch (Exception __e) { throw rethrow(__e); } }


static <A> boolean containsExceptionOfType(Class<A> c, Throwable e) {
  return containsException(c, e);
}

static <A> boolean containsExceptionOfType(Throwable e, Class<A> c) {
  return containsExceptionOfType(c, e);
}


static String stackTraceToString(StackTraceElement[] st) {
  return lines(st);
}

static String stackTraceToString(Throwable e) {
  return getStackTrace_noRecord(e);
}


static String getBotAddress(String bot) {
  List<ScannedBot> l = fullBotScan(bot);
  return empty(l) ? null : first(l).address;
}


static Object unstructure_matchOK2OrFail(String s) {
  if (swic(s, "ok "))
    return unstructure_startingAtIndex(s, 3);
  else
    throw fail(s);
}


static String sendToLocalBot(String bot, String text, Object... args) {
  text = format3(text, args);
  
   DialogIO channel = findBot(bot); try {
  if (channel == null)
    throw fail(quote(bot) + " not found");
  try {
    channel.readLine();
    print(bot + "> " + shorten(text, 80));
    channel.sendLine(text);
    String s = channel.readLine();
    print(bot + "< " + shorten(s, 80));
    return s;
  } catch (Throwable e) {
    e.printStackTrace();
    return null;
  }
} finally { _close(channel); }}

static String sendToLocalBot(int port, String text, Object... args) {
  text = format3(text, args);
   DialogIO channel = talkTo(port); try {
  try {
    channel.readLine();
    print(port + "> " + shorten(text, 80));
    channel.sendLine(text);
    String s = channel.readLine();
    print(port + "< " + shorten(s, 80));
    return s;
  } catch (Throwable e) {
    e.printStackTrace();
    return null;
  }
} finally { _close(channel); }}


static TimerTask timerTask(final Object r, final java.util.Timer timer) {
  return new TimerTask() {
    public void run() {
      
      if (!licensed())
        timer.cancel();
      else
        pcallF(r);
    }
  };
}


static long clockToSysTimeDiff() {
  return sysNow()-now();
}


static 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 <A> List<A> cloneAndClearList(Collection<A> l) {
  List<A> l2 = cloneList(l);
  l.clear();
  return l2;
}




static class jLiveValueSection_class extends SingleComponentPanel {
  LiveValue<?> liveValue;
  
  String getTitle() { return strOrEmpty(liveValue.get()); }
  
  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 JPanel jLiveValueSection(LiveValue<?> lv, Component c) {
  return swingNu(jLiveValueSection_class.class, lv, c);
}


static JScrollPane setScrollPaneBackground(Color c, JScrollPane sp) {
  if (sp != null && c != null) { swing(() -> {  sp.getViewport().setBackground(c); }); }
  return sp;
}


static <A extends JComponent> A withTypeWriterFont(A c) {
  return setFont(c, typeWriterFont());
}


static void clearStringBuffer_gen(Object buf) {
  if (buf != null) {
    call(buf, "setLength", 0);
    call(buf, "trimToSize");
  }
}


static DynModule dm_current_mandatory() {
  return assertNotNull("No module set!", dm_currentModule());
}


static void swingEvery(JComponent component, long delay, Object r) {
  installTimer(component, delay, r);
}

static void swingEvery(JComponent component, long delay, long firstDelay, Object r) {
  installTimer(component, r, delay, firstDelay);
}

static void swingEvery(RootPaneContainer frame, long delay, Object r) {
  installTimer(frame, delay, r);
}

static void swingEvery(RootPaneContainer frame, long delay, long firstDelay, Object r) {
  installTimer(frame, delay, firstDelay, r);
}


static 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 void swingLater(Object r) {
  var runnable = toRunnable(r);
  executingSwingCode(runnable);
  SwingUtilities.invokeLater(runnable);
}







// first delay = delay
static Timer installTimer(JComponent component, Object r, long delay) {
  return installTimer(component, r, delay, delay);
}

// first delay = delay
static Timer installTimer(RootPaneContainer frame, long delay, Object r) {
  return installTimer(frame.getRootPane(), r, delay, delay);
}

// first delay = delay
static Timer installTimer(JComponent component, long delay, Object r) {
  return installTimer(component, r, delay, delay);
}

static Timer installTimer(JComponent component, long delay, long firstDelay, Object r) {
  return installTimer(component, r, delay, firstDelay);
}

static Timer installTimer(final JComponent component, final Object r, final long delay, final long firstDelay) {
  return installTimer(component, r, delay, firstDelay, true);
}

static 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) { pcallFail(__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 Timer installTimer(RootPaneContainer frame, long delay, long firstDelay, Object r) {
  return installTimer(frame.getRootPane(), delay, firstDelay, r);
}



static StringBuffer liveLocalPrintLog() {
  return local_log;
}




static String localDateWithSeconds(long time) {
  SimpleDateFormat format = simpleDateFormat_local("yyyy/MM/dd HH:mm:ss");
  return format.format(time);
}

static String localDateWithSeconds() {
  return localDateWithSeconds(now());
}


static Complex complex(double re, double im) {
  return new Complex(re, im);
}

static Complex complex(double re) {
  return new Complex(re, 0.0);
}

static 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 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 int toInt_checked(long l) {
  if (l != (int) l) throw fail("Too large for int: " + l);
  return (int) l;
}


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


static 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 <A> List<A> asSynchroList(Iterable<A> l) {
  return syncList(cloneList(l));
}



static 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 String lines_rtrim(Collection lines) {
  return rtrim_fromLines(lines);
}


static void raiseFlagAndDo(Flag flag, Runnable r) {
  if (flag.raise()) callF(r);
}


static void _handleException_addHandler(Object handler) {
  addIfNotThere(_handleException_onException, handler);
}

static void _handleException_addHandler(IVF1<Throwable> handler) {
  _handleException_addHandler((Object) handler);
}


static <A> A assertNull(A a) {
  assertTrue(a == null);
  return a;
}

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


static <A, B> void mapPut(Map<A, B> map, A key, B value) {
  if (map != null && key != null && value != null) map.put(key, value);
}


static <A, B> void mapPut(Map<A, B> map, Pair<A, B> p) {
  if (map != null && p != null) map.put(p.a, p.b);
}



static <A extends Component> A internalFrameTitle(A c, final String title) {
  final JInternalFrame f = getInternalFrame(c);
  if (f != null) { swing(() -> { 
    f.setTitle(unnull(title));
    toolTip(getInternalFrameTitlePaneComponent(f), title);
  }); }
  return c;
}

static <A extends Component> A internalFrameTitle(String title, A c) {
  return internalFrameTitle(c, title);
}

static String internalFrameTitle(Component c) {
  final JInternalFrame f = getInternalFrame(c);
  return f == null ? null : swing(new F0<String>() { public String get() { try {  return f.getTitle();  } catch (Exception __e) { throw rethrow(__e); } }
  public String toString() { return "return f.getTitle();"; }});
}



static <A extends Component> A frameTitle(A c, String title) {
  return setFrameTitle(c, title);
}

static <A extends Component> A frameTitle(String title, A c) {
  return setFrameTitle(c, title);
}

static String frameTitle(Component c) {
  return getFrameTitle(c);
}



static 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 boolean interruptThread_verbose = false;

static void interruptThread(Thread t) {
  if (t == null) return;
  if (interruptThread_verbose) print("Interrupting thread " + t);
  
  // note reason in global map
  
  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) { pcallFail(__e); }}
}


static boolean isTransientField(Object object, String name) {
  Field f = getField(object, name);
  return f != null && (f.getModifiers() & Modifier.TRANSIENT) != 0;
}


static <A> A shallowCloneToClass(Class<A> c, Object o) {
  if (o == null) return null;
  A a = nuInstance(c);
  copyFields(o, a);
  return a;
}


static 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 void dm_onTopInput(final VF1<String> r) {
  final DynModule m = dm_current_mandatory();
  dm_ownResource(vmBus_onMessage("topInput", new VF1<String>() { public void get(final String s) { try { 
    m.enter();
    callF(r, s)
  ; } catch (Exception __e) { throw rethrow(__e); } }
  public String toString() { return "m.enter();\r\n    callF(r, s)"; }}));
}

static void dm_onTopInput(final Runnable r) {
  final DynModule m = dm_current_mandatory();
  dm_ownResource(vmBus_onMessage("topInput", new VF1<String>() { public void get(final String s) { try { 
    m.enter();
    callF(r)
  ; } catch (Exception __e) { throw rethrow(__e); } }
  public String toString() { return "m.enter();\r\n    callF(r)"; }}));
}


static void pClose(AutoCloseable c) {
  close_pcall(c);
}


static <A, B> A foldl(F2<A, B, A> f, A seed, Iterable<B> l) {
  A a = seed;
  if (l != null) for(B b : l)
    a = callF(f, a, b);
  return a;
}

static <A, B> A foldl(F2<A, B, A> f, A seed, B[] l) {
  A a = seed;
  if (l != null) for(B b : l)
    a = callF(f, a, b);
  return a;
}

static <A, B> A foldl(Object f, A seed, B[] l) {
  A a = seed;
  if (l != null) for(B b : l)
    a = (A) callF(f, a, b);
  return a;
}


static <A> boolean setAdd(Collection<A> c, A a) {
  if (c == null || c.contains(a)) return false;
  c.add(a);
  return true;
}


static ChangeListener changeListener(final Object r) {
  return new ChangeListener() {
    public void stateChanged(ChangeEvent e) {
      pcallF(r);
    }
  };
}


static ItemListener itemListener(final Object r) {
  return new ItemListener() {
    public void itemStateChanged(ItemEvent e) {
      pcallF(r);
    }
  };
}


static void addActionListener(JTextField tf, final Runnable action) {
  onEnter(tf, action);
}

static void addActionListener(final JComboBox cb, final Runnable action) {
  if (cb != null) { swing(() -> { 
    cb.addActionListener(actionListener(action));
  }); }
}

static void addActionListener(final AbstractButton b, final Runnable action) {
  if (b != null) { swing(() -> { 
    b.addActionListener(actionListener(action));
  }); }
}


static <A> A getSelectedItem_typed(JList<A> l) {
  return swing(() -> l.getSelectedValue());
}

static <A> A getSelectedItem_typed(JComboBox<A> cb) {
  return swing(() -> (A) cb.getSelectedItem());
}


static JTextField textFieldFromComboBox(JComboBox cb) {
  return (JTextField) cb.getEditor().getEditorComponent();
}


static 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 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 <A> IVF1<A> runnableToIVF1(Runnable r) {
  return r == null ? null : a -> r.run();
}


static 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 void internalFramePopupMenuItem(Container f, final String name, final Object action) {
  internalFrameTitlePopupMenuItem(((JInternalFrame) f), name, action);
}


static void callAction(Action a) {
  if (a != null) a.actionPerformed(null);
}


static <A, B> Map<A, B> weakHashMap() {
  return newWeakHashMap();
}


static <A> TreeSet<A> asTreeSet(Collection<A> set) {
  return set == null ? null : set instanceof TreeSet ? (TreeSet) set : new TreeSet(set);
}


static Field getField(Object o, String field) {
  if (o == null) return null;
  return setOpt_findField(_getClass(o), field);
}

static Object getField(Field field, Object o) {
  return fieldGet(field, o);
}


static Map<String, String> humanizeFormLabel_replacements = litmap("id" , "ID", "md5" , "MD5");

static String humanizeFormLabel(String s) {
  if (!isIdentifier(s)) return s;
  return firstToUpper(
    joinWithSpace(replaceElementsUsingMap(splitCamelCase(s), humanizeFormLabel_replacements)).replace("I D", "ID")
  );
}


// menuMaker = voidfunc(JPopupMenu)
static void internalFrameTitlePopupMenu(final JInternalFrame f, final Object... params) {
  { swing(() -> { 
    Object menuMaker;
    if (l(params) == 1 && !(params[0] instanceof JMenu))
      menuMaker = params[0];
    else
      menuMaker = new VF1<JPopupMenu>() { public void get(JPopupMenu menu) { try {  addMenuItems(menu, params) ; } catch (Exception __e) { throw rethrow(__e); } }
  public String toString() { return "addMenuItems(menu, params)"; }};
    
    Component titleComponent = getInternalFrameTitlePaneComponent(f);
    if (!(titleComponent instanceof JComponent))
      print("Can't add internal frame title popup menu!");
    else {
      componentPopupMenu((JComponent) titleComponent, menuMaker);
      setOpt(componentPopupMenu_initForComponent((JComponent) titleComponent), "internalFrameLeftButtonMagic" , isTrue(vm_generalMap_get("internalFramePopupOnLeftButton")));
    }
      
    // Also add to the frame so we can show the items e.g. in a JFrame menu
    componentPopupMenu(f, menuMaker);
  }); }
}


// r : runnable or voidfunc(bool)
static 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 JCheckBoxMenuItem jCheckBoxMenuItem(String text, boolean checked, IVF1<Boolean> r) {
  return jCheckBoxMenuItem(text, checked, (Object) r);
}



static JTextField jtextfield() {
  return jTextField();
}

static JTextField jtextfield(String text) {
  return jTextField(text);
}

static JTextField jtextfield(Object o) {
  return jTextField(o);
}



static int showForm_defaultGap = 4;
static int showForm_gapBetweenColumns = 10;

static JPanel showFormTitled(final String title, final Object... _parts) {
  JDesktopPane desktop = mainDesktopPane();
  if (desktop != null) return showInternalFrameFormTitled(desktop, title, _parts);
  return swing(() -> {
    JPanel panel = showForm_makePanel(false, _parts);
    showForm_makeFrame(title, panel);
    return panel;
  });
}

static JPanel showForm_makePanel(Boolean internalFrame, Object... _parts) {
  List<JComponent> out = showForm_arrange1(showForm_makeComponents(internalFrame, _parts));
  return vstackWithSpacing(out, showForm_defaultGap);
}


static String stringOptPar(Object[] params, String name) {
  return (String) optPar(params, name);
}


static String gtt(JTextComponent c) {
  return getTextTrim(c);
}

static String gtt(JComboBox cb) {
  return getTextTrim(cb);
}


static void dm_doubleFieldSetterDialog(String field, Object... __) {
  final DynModule m = dm_current_mandatory();
  final String humanized = humanizeFormLabel(field);
  final JTextField tf = jtextfield(get(m, field));
  showFormTitled(or2(stringOptPar(__, "formTitle"), "Set " + humanized),
    humanized + ":", tf, new Runnable() {  public void run() { try { 
      m.setField(field, parseDouble(gtt(tf)));
      callF(optPar(__, "onSet"));
    
} catch (Exception __e) { throw rethrow(__e); } }  public String toString() { return "m.setField(field, parseDouble(gtt(tf)));\r\n      callF(optPar(__, \"onSet\"));"; }});
}


static void dm_floatFieldSetterDialog(String field, Object... __) {
  DynModule m = dm_current_mandatory();
  String humanized = humanizeFormLabel(field);
  JTextField tf = jtextfield(get(m, field));
  showFormTitled(or2(stringOptPar(__, "formTitle"), "Set " + humanized),
    humanized + ":", tf, new Runnable() {  public void run() { try { 
      m.setField(field, parseFloat(gtt(tf)));
      callF(optPar(__, "onSet"));
    
} catch (Exception __e) { throw rethrow(__e); } }  public String toString() { return "m.setField(field, parseFloat(gtt(tf)));\r\n      callF(optPar(__, \"onSet\"));"; }});
}


static void dm_stringFieldDialog(final String field, final Object... __) {
  final DynModule m = dm_current_mandatory();
  final String humanized = humanizeFormLabel(field);
  final JTextField tf = jtextfield(get(m, field));
  showFormTitled(or2(stringOptPar(__, "formTitle"), "Set " + humanized),
    humanized + ":", tf, new Runnable() {  public void run() { try { 
      m.setField(field, gtt(tf));
      callF(optPar(__, "onSet"));
    
} catch (Exception __e) { throw rethrow(__e); } }  public String toString() { return "m.setField(field, gtt(tf));\r\n      callF(optPar(__, \"onSet\"));"; }});
}


static void dm_fileFieldDialog(final String field, final Object... __) {
  DynModule m = dm_current_mandatory();
  String humanized = humanizeFormLabel(field);
  JTextField tf = jtextfield(strOrNull(get(m, field)));
  showFormTitled(or2(stringOptPar(__, "formTitle"), "Set " + humanized),
    humanized + ":", tf, new Runnable() {  public void run() { try { 
      m.setField(field, toFile_nullOnEmpty(gtt(tf)));
      callF(optPar(__, "onSet"));
    
} catch (Exception __e) { throw rethrow(__e); } }  public String toString() { return "m.setField(field, toFile_nullOnEmpty(gtt(tf)));\r\n      callF(optPar(__, \"onSe..."; }});
}


static Q dm_ownQ(Q q) {
  q.rst.enter = dm_rEnter(dm_current_mandatory()); 
  dm_ownResource(q);
  return q;
}


static Q startQ() {
  return new Q();
}

static Q startQ(String name) {
  return new Q(name);
}


static JLabel jimage(Image img) {
  return jImageLabel(img);
}

static JLabel jimage(String imageID) {
  return jImageLabel(imageID);
}


static <A> Set<A> newWeakHashSet() {
  return synchroWeakHashSet();
}


static void cancelTimers(Collection timers) {
  for (Object timer : timers) cancelTimer(timer);
}


static String assertPossibleGlobalID(String s) {
  if (!possibleGlobalID(s))
    throw fail("Not an acceptable global ID: " + s);
  return s;
}


static char charPlus(char a, int b) {
  return (char) (((int) a) + b);
}

static char charPlus(int b, char a) {
  return charPlus(a, b);
}


// better modulo that gives positive numbers always
static int mod(int n, int m) {
  return (n % m + m) % m;
}

static long mod(long n, long m) {
  return (n % m + m) % m;
}

static BigInteger mod(BigInteger n, int m) {
  return n.mod(bigint(m));
}

static double mod(double n, double m) {
  return (n % m + m) % m;
}




static String div(Object contents, Object... params) {
  return hdiv(contents, params);
}

static String div() {
  return hdiv();
}


static BigInteger div(BigInteger a, BigInteger b) {
  return a.divide(b);
}

static BigInteger div(BigInteger a, int b) {
  return a.divide(bigint(b));
}


static Complex div(Complex a, double b) {
  return new Complex(a.re/b, a.im/b);
}


static double div(double a, double b) { return a/b; }
static double div(double a, int b) { return a/b; }
static long div(long a, long b) { return a/b; }
static int div(int a, int b) { return a/b; }


static int incAtomicInt(AtomicInteger i) {
  return i.incrementAndGet();
}

static int incAtomicInt(AtomicInteger i, int delta) {
  return i.addAndGet(delta);
}


static long incAtomicLong(AtomicLong l) {
  return l.incrementAndGet();
}


static String intToHex(int i) {
  return bytesToHex(intToBytes(i));
}


static <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 void cancelThread(Thread t) {
  if (t == null) return;
  ping();
  
  
  
  
  
    synchronized(ping_actions) {
      ping_actions.put(t, "cancelled");
      ping_anyActions = true;
    }
  
  
  
}




static volatile PersistableThrowable _handleException_lastException;
static List _handleException_onException = synchroList(ll((IVF1<Throwable>) (__1 -> printStackTrace2(__1))));
static boolean _handleException_showThreadCancellations = false;

static 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); // not using pcall here - it could lead to endless loops
    } catch (Throwable e4) {
      System.out.println(getStackTrace(e3));
      System.out.println(getStackTrace(e4));
    }
  }
}


static <A> boolean addIfNotNull(Collection<A> l, A a) {
  return a != null && l != null & l.add(a);
}


static <A> void addIfNotNull(MultiSet<A> ms, A a) {
  if (a != null && ms != null) ms.add(a);
}



static 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 boolean containsIgnoreCase(Collection<String> l, String s) {
  if (l != null) for (String x : l)
    if (eqic(x, s))
      return true;
  return false;
}

static boolean containsIgnoreCase(String[] l, String s) {
  if (l != null) for (String x : l)
    if (eqic(x, s))
      return true;
  return false;
}

static boolean containsIgnoreCase(String s, char c) {
  return indexOfIgnoreCase(s, String.valueOf(c)) >= 0;
}

static boolean containsIgnoreCase(String a, String b) {
  return indexOfIgnoreCase(a, b) >= 0;
}




static String formatWithThousandsSeparator(long l) {
  return NumberFormat.getInstance(new Locale("en_US")).format(l);
}


static int localYear() {
  return localYear(now());
}

static int localYear(long time) {
  return parseInt(simpleDateFormat_local("yyyy").format(time));
}


static long toLong(Object o) {
  if (o instanceof Number)
    return ((Number) o).longValue();
  if (o instanceof String)
    return parseLong((String) o);
  return 0;
}

static long toLong(Timestamp ts) {
  return ts == null ? 0 : ts.unixDate();
}

static long toLong(Date d) {
  return d == null ? 0 : d.getTime();
}


static java.text.SimpleDateFormat simpleDateFormat(String format, TimeZone timeZone) {
  java.text.SimpleDateFormat sdf = new java.text.SimpleDateFormat(format);
  sdf.setTimeZone(timeZone);
  return sdf;
}


static int localMonth(long time) {
  return parseInt(simpleDateFormat_local("MM").format(time));
}

static int localMonth() {
  return localMonth(now());
}


static int localDayOfMonth(long time) {
  return parseInt(simpleDateFormat_local("dd").format(time));
}

static int localDayOfMonth() {
  return localDayOfMonth(now());
}


static double floor(double d) {
  return Math.floor(d);
}


static AutoCloseable tempActivity(Object r) {
  return null;
}


static long fixTimestamp(long timestamp) {
  return timestamp > now() ? 0 : timestamp;
}


static <A> ArrayList<A> cloneListSynchronizingOn(Collection<A> l, Object mutex) {
  if (l == null) return new ArrayList();
  synchronized(mutex) {
    return new ArrayList<A>(l);
  }
}


static <A> List<A> sorted(Collection<A> c, Object comparator) {
  List<A> l = cloneList(c);
  sort(l, makeComparator(comparator));
  return l;
}

static <A> List<A> sorted(Collection<A> c) {
  List<A> l = cloneList(c);
  sort(l);
  return l;
}

static <A> List<A> sorted(Comparator<A> comparator, Collection<A> c) {
  List<A> l = cloneList(c);
  sort(l, comparator);
  return l;
}


static 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 boolean isJavaXClassLoader(ClassLoader cl) {
  return startsWithOneOf(className(cl), "main$JavaXClassLoader", "x30$JavaXClassLoader");
}


static void setOptAll(Object o, Map<String, Object> fields) {
  if (fields == null) return;
  for (String field : keys(fields))
    setOpt/*_flex*/(o, field, fields.get(field));
}

static void setOptAll(Object o, Object... values) {
  //values = expandParams(c.getClass(), 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 String loadGZTextFile(File file) { try {
  if (!file.isFile()) return null;
  ping();
  ByteArrayOutputStream baos = new ByteArrayOutputStream();
   InputStream fis = new FileInputStream(file); try {
  GZIPInputStream gis = newGZIPInputStream(fis);
  byte[] buffer = new byte[1024];
  int len;
  while ((len = gis.read(buffer)) != -1) baos.write(buffer, 0, len);
  baos.close();
  return fromUtf8(baos.toByteArray()); // TODO: use a Reader
} finally { _close(fis); }} catch (Exception __e) { throw rethrow(__e); } }


static Object getTL(Object o, String name) {
  return getThreadLocal(o, name);
}

static <A> A getTL(ThreadLocal<A> tl) {
  return getThreadLocal(tl);
}

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




// non-strings must be Comparable to each other
// probably this is not that useful after all

static generalizedCIComparator_C generalizedCIComparator_cache;
static generalizedCIComparator_C generalizedCIComparator() { if (generalizedCIComparator_cache == null) generalizedCIComparator_cache = generalizedCIComparator_load(); return generalizedCIComparator_cache;}

static generalizedCIComparator_C generalizedCIComparator_load() {
  return new generalizedCIComparator_C();
}

final static class generalizedCIComparator_C implements Comparator<Object> {
  public int compare(Object o1, Object o2) {
    if (o1 instanceof String)
      if (o2 instanceof String)
        return betterCIComparator().compare(((String) o1), ((String) o2));
      else
        return -1;
    else
      if (o2 instanceof String)
        return 1;
    else
      return cmp(o1, o2);
  }
}


static Matcher regexpMatcherIC(String pat, String s) {
  return compileRegexpIC(pat).matcher(unnull(s));
}


static String dropFrom(String s, String x) {
  if (s == null) return null;
  int i = s.indexOf(x);
  if (i < 0) return s;
  return substring(s, 0, i);
}


static boolean regexpMatchesIC(String pat, String s) {
  return regexpICMatches(pat, s);
}



static boolean regexpMatchesIC(Pattern pat, String s) {
  return regexpICMatches(pat, s);
}




static Object jsonDecode(String text) {
  return new jsonDecode_Y(text).parse();
}

// the miraculous class Y
static class jsonDecode_Y {
  String text;
  List<String> tok;
  boolean useOrderedMaps = false;
  int i = 1;

  jsonDecode_Y(String text) {
  this.text = text;
    tok = jsonTok(text);
  }
  
  transient  IF1<String, RuntimeException> fail;
RuntimeException fail(String msg) { return fail != null ? fail.get(msg) : fail_base(msg); }
final RuntimeException fail_fallback(IF1<String, RuntimeException> _f, String msg) { return _f != null ? _f.get(msg) : fail_base(msg); }
RuntimeException fail_base(String msg) { return main.fail(msg); }
  
  Object parse() {
    if (l(tok) == 1) return null;
    return parseExpr();
  }
  
  Object parseExpr() {
    String t = tok.get(i);
    if (t.startsWith("\"") || t.startsWith("'")) {
      String s = unquote(tok.get(i));
      i += 2;
      return s;
    }
    if (t.equals("{"))
      return parseMap();
    if (t.equals("["))
      return this.parseList(); // avoid loading standard function "parseList"
    if (t.equals("null")) {
      i += 2; return null;
    }
    if (t.equals("false")) {
      i += 2; return false;
    }
    if (t.equals("true")) {
      i += 2; return true;
    }
    boolean minus = false;
    if (t.equals("-")) {
      minus = true;
      i += 2;
      t = get(tok, i);
    }
    if (isInteger(t)) {
      int j = i;
      i += 2;
      if (eqOneOf(get(tok, i), ".", "e", "E")) {
        // rough parsing for doubles
        while (isInteger(get(tok, i))
          || eqOneOf(get(tok, i), ".", "e", "E", "-"))
          i += 2;
        double d = parseDouble(joinSubList(tok, j, i-1));
        if (minus) d = -d;
        return d;
      } else {
        long l = parseLong(t);
        return boxedIntOrLong(minus ? -l : l);
      }
    }
    
    throw fail("Unknown token " + (i+1) + ": " + t + ": " + text);
  }
  
  Object parseList() {
    consume("[");
    List list = new ArrayList();
    while (!tok.get(i).equals("]")) {
      list.add(parseExpr());
      if (tok.get(i).equals(",")) i += 2;
    }
    consume("]");
    return list;
  }
  
  Object parseMap() {
    consume("{");
    Map map = useOrderedMaps ? new LinkedHashMap() : new TreeMap();
    while (!tok.get(i).equals("}")) {
      String key = unquote(tok.get(i));
      i += 2;
      consume(":");
      Object value = parseExpr();
      map.put(key, value);
      if (tok.get(i).equals(",")) i += 2;
    }
    consume("}");
    return map;
  }
  
  void consume(String s) {
    if (!tok.get(i).equals(s)) {
      String prevToken = i-2 >= 0 ? tok.get(i-2) : "";
      String nextTokens = join(tok.subList(i, Math.min(i+4, tok.size())));
      throw fail(quote(s) + " expected: " + prevToken + " " + nextTokens + " (" + i + "/" + tok.size() + ")");
    }
    i += 2;
  }
}


static void indexConceptField(Class<? extends Concept> c, String field) {
  indexConceptField(db_mainConcepts(), c, field);
}

static void indexConceptField(Concepts concepts, Class<? extends Concept> c, String field) {
  if (!isConceptFieldIndexed(concepts, c, field))
    new ConceptFieldIndex(concepts, c, field);
}


static void dm_onFieldChange(String field, Runnable onChange) {
  dm_watchField(field, onChange);
}

static void dm_onFieldChange(Collection<String> fields, Runnable onChange) {
  dm_watchFields(fields, onChange);
}


static void dm_reloadModule(Object module) {
  dm_reloadModuleInBackground(module);
}

static void dm_reloadModule() {
  dm_reloadModuleInBackground();
}


static char[] asChars(String s) {
  return s == null ? null : s.toCharArray();
}


static List<File> sortFilesByName(List<File> l) {
  sort(l, (a, b) -> stdcompare(a.getName(), b.getName()));
  return l;
}


static 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 List<File> listDirs(String dir) {
  return listDirs(newFile(dir));
}


static boolean isFile(File f) {
  return f != null && f.isFile();
}

static boolean isFile(String path) {
  return isFile(newFile(path));
}


static <A> A getSingleton(List<A> l) {
  assertEquals(1, l(l));
  return first(l);
}

static <A> A getSingleton(A[] l) {
  assertEquals(1, l(l));
  return first(l);
}


static <A> A getSingleton(IMultiSet<A> ms) {
  assertEquals(1, l(ms));
  return first(ms);
}





static DynModule dm_current() {
  return dm_currentModule();
}


static void closeAutoCloseables(Collection<AutoCloseable> l) {
  if (l != null) for (AutoCloseable c : l) { try { c.close(); } catch (Throwable __e) { pcallFail(__e); }}
}


static 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 <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 Object dm_stem() { return dm_stem(dm_current_generic()); }
static Object dm_stem(Object moduleOrID) {
  return dm_getStem(moduleOrID);
}


static <A> A dm_getOSOpt(String field) {
  return (A) getOpt(dm_os(), field);
}


static <A> List<A> lambdaFilter(Iterable<A> c, Object pred) {
  return filter(c, pred);
}



static List lambdaFilter(Object pred, Iterable c) {
  return filter(pred, c);
}



static <A, B extends A> List<B> lambdaFilter(Iterable<B> c, F1<A, Boolean> pred) {
  return filter(c, pred);
}



static <A, B extends A> List<B> lambdaFilter(F1<A, Boolean> pred, Iterable<B> c) {
  return filter(pred, c);
}



//ifclass IF1
static <A, B extends A> List<B> lambdaFilter(Iterable<B> c, IF1<A, Boolean> pred) {
  return filter(c, pred);
}



static <A, B extends A> List<B> lambdaFilter(B[] c, IF1<A, Boolean> pred) {
  return filter(c, pred);
}



static <A, B extends A> List<B> lambdaFilter(IF1<A, Boolean> pred, Iterable<B> c) {
  return filter(pred, c);
}


static boolean isNonSynthetic(Method m) {
  return m != null && !m.isSynthetic();
}


// finds static and non-static methods.

static List<Method> findMethodsNamed(Object obj, String method) {
  if (obj == null) return null;
  return findMethodsNamed(_getClass(obj), method);
}

static List<Method> findMethodsNamed(Class c, String method) {
  List<Method> l = new ArrayList();
  while (c != null) {
    for (Method m : c.getDeclaredMethods())
      if (m.getName().equals(method)) {
        m.setAccessible(true);
        l.add(m);
      }
    c = c.getSuperclass();
  }
  return l;
}



static List<Method> findMethodsNamed(String method, Object obj) {
  return findMethodsNamed(obj, method);
}


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



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



// If you change this, also change DiskSnippetCache_fileToLibID
static File DiskSnippetCache_file(long snippetID) {
  return new File(getGlobalCache(), "data_" + snippetID + ".jar");
}
  
// Data files are immutable, use centralized cache
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 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 long fileSize(String path) { return getFileSize(path); }
static long fileSize(File f) { return getFileSize(f); }



static 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 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));
    }
    // TODO: check if we hit the "LOADING" message
    if (fileSize(f) == 0) throw fail();
    System.err.println("Bytes loaded: " + fileSize(f));
  } catch (Throwable e) {
    //printStackTrace(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 <A> A println(A a) {
  return print(a);
}


static String hopeningTag(String tag, Map params) {
  return hopeningTag(tag, mapToParams(params));
}

static 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 boolean startsWithIC(String a, String b) { return startsWithIgnoreCase(a, b); }


static <A> A firstWithClassShortNamed(String shortName, Iterable<A> l) {
  if (l != null) for (A o : l)
    if (eq(shortClassName(o), shortName))
      return o;
  return null;
}

static <A> A firstWithClassShortNamed(String shortName, A[] l) {
  if (l != null) for (A o : l)
    if (eq(shortClassName(o), shortName))
      return o;
  return null;
}


static Object costCenter() { return mc(); }


static Object callJavaX(String method, Object... args) {
  return callOpt(getJavaX(), method, args);
}


static Random defaultRandomizer() {
  return defaultRandomGenerator();
}


static <A> A listGet(List<A> l, int idx) {
  return l != null && idx >= 0 && idx < l.size() ? l.get(idx) : null;
}


static <A> IterableIterator<A> iteratorFromFunction_f0(final F0<A> f) {
  class IFF2 extends IterableIterator<A> {
    A a;
    boolean done = false;
    
    public boolean hasNext() {
      getNext();
      return !done;
    }
    
    public A next() {
      getNext();
      if (done) throw fail();
      A _a = a;
      a = null;
      return _a;
    }
    
    void getNext() {
      if (done || a != null) return;
      a = f.get();
      done = a == null;
    }
  };
  return new IFF2();
}


static <A> IterableIterator<A> iteratorFromFunction_if0(final IF0<A> f) {
  class IFF2 extends IterableIterator<A> {
    A a;
    boolean done = false;
    
    public boolean hasNext() {
      getNext();
      return !done;
    }
    
    public A next() {
      getNext();
      if (done) throw fail();
      A _a = a;
      a = null;
      return _a;
    }
    
    void getNext() {
      if (done || a != null) return;
      a = f.get();
      done = a == null;
    }
  };
  return new IFF2();
}


static IterableIterator<String> lines_iterator(final String s) {
  if (s == null) return emptyIterableIterator();
  return iteratorFromFunction(new F0<String>() {
    int start = 0;
    
    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 <A> boolean containsException(Class<A> c, Throwable e) {
  return unpackExceptionAs(c, e) != null;
}


static class ScannedBot implements IFieldsToList{
  static final String _fieldOrder = "helloString address";
  String helloString;
  String address;
  ScannedBot() {}
  ScannedBot(String helloString, String address) {
  this.address = address;
  this.helloString = helloString;}
  public String toString() { return shortClassName_dropNumberPrefix(this) + "(" + helloString + ", " + address + ")"; }

public boolean equals(Object o) {
if (!(o instanceof ScannedBot)) return false;
    ScannedBot __1 =  (ScannedBot) o;
    return eq(helloString, __1.helloString) && eq(address, __1.address);
}

  public int hashCode() {
    int h = 1660478935;
    h = boostHashCombine(h, _hashCode(helloString));
    h = boostHashCombine(h, _hashCode(address));
    return h;
  }
  public Object[] _fieldsToList() { return new Object[] {helloString, address}; }
}

static List<ScannedBot> fullBotScan() {
  return fullBotScan("");
}

static List<ScannedBot> fullBotScan(String searchPattern) {
  List<ScannedBot> bots = new ArrayList();
  for (ProgramScan.Program p : quickBotScan()) {
    String botName = firstPartOfHelloString(p.helloString);
    boolean isVM = startsWithIgnoreCase(p.helloString, "This is a JavaX VM.");
    boolean shouldRecurse = swic(botName, "Multi-Port") || isVM;
    
    if (swic(botName, searchPattern)) bots.add(new ScannedBot(botName, "" + p.port));

    if (shouldRecurse) try {
      Map<Number, String> subBots = (Map) unstructure(sendToLocalBotQuietly(p.port, "list bots"));
      for (Number vport : subBots.keySet()) {
        botName = subBots.get(vport);
        if (swic(botName, searchPattern)) 
          bots.add(new ScannedBot(botName, p.port + "/" + vport));
      }
    } catch (Exception e) { e.printStackTrace(); }
  }
  return bots;
}


static Object unstructure_startingAtIndex(String s, int i) {
  return unstructure_tok(javaTokC_noMLS_iterator(s, i), false, null);
}


static <A extends JComponent> A bindLiveValueListenerToComponent(A component, IHasChangeListeners lv, Runnable listener) {
  return bindHasChangeListenersToComponent(component, lv, listener);
}




static <A extends JComponent> A setBorder(Border border, A c) {
  if (c != null) { swing(() -> {  c.setBorder(border); }); }
  return c;
}



static <A extends JComponent> A setBorder(A c, Border border) {
  return setBorder(border, c);
}


static <A extends JComponent> A setFont(final Font font, final A a) {
  if (a != null) { swing(() -> {  a.setFont(font); }); }
  return a;
}

static <A extends JComponent> A setFont(A a, Font font) {
  return setFont(font, a);
}

static <A extends JComponent> A setFont(final String fontID, float fontSize, final A a) {
  return setFont(loadFont_cached(fontID, fontSize), a);
}


static Font typeWriterFont() {
  return typeWriterFont(iround(14*getSwingFontScale()));
}
  
static Font typeWriterFont(int size) {
  return new Font(localCourierFontName(), Font.PLAIN, size);
}

static <A extends JComponent> A typeWriterFont(A c) {
  return withTypeWriterFont(c);
}


static boolean allPaused() {
  return ping_pauseAll;
}




static void bindTimerToComponent(final Timer timer, JFrame f) {
  bindTimerToComponent(timer, f.getRootPane());
}

static 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 SimpleDateFormat simpleDateFormat_local(String format) {
  SimpleDateFormat sdf = new SimpleDateFormat(format);
  sdf.setTimeZone(localTimeZone());
  return sdf;
}


static boolean containsNewLines(String s) {
  return containsNewLine(s);
}


static String jlabel_textAsHTML_center(String text) {
  return "<html><div style=\"text-align: center;\">"
    + replace(htmlencode2(text), "\n", "<br>")
    + "</div></html>";
}


static 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 JComponent getInternalFrameTitlePaneComponent(JInternalFrame f) {
  return (JComponent) childWithClassNameEndingWith(f, "InternalFrameTitlePane");
}



static <A> A setFrameTitle(A c, final String title) {
  final Frame f = getAWTFrame(c);
  if (f != null) { swing(() -> {  f.setTitle(title); }); }
  return c;
}

static <A extends Component> A setFrameTitle(String title, A c) {
  return setFrameTitle(c, title);
}

// magically find a field called "frame" in main class :-)
static JFrame setFrameTitle(String title) {
  Object f = getOpt(mc(), "frame");
  if (f instanceof JFrame)
    return setFrameTitle((JFrame) f, title);
  return null;
}


static String getFrameTitle(Component c) {
  JFrame f = getFrame(c);
  return f == null ? null : f.getTitle();
}


static <A> A nuInstance(Class<A> c) {
  return nuEmptyObject(c);
}


static <A> A copyFields(Object x, A y, String... fields) {
  if (empty(fields)) { // assume we should copy all fields
    Map<String, Object> map = objectToMap(x);
    for (String field : map.keySet())
      setOpt(y, field, map.get(field));
  } else 
    for (String field : fields) {
      Object o = getOpt(x, field);
      if (o != null)
        setOpt(y, field, o);
    }
  return y;
}

static <A> A copyFields(Object x, A y, Collection<String> fields) {
  return copyFields(x, y, asStringArray(fields));
}


// return Int.MAX_VALUE if not applicable
// Lower score is better
static int methodApplicabilityScore_onTypes(Method m, Class[] argTypes) {
  return methodApplicabilityScore_onTypes((Executable) m, argTypes);
}

static 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) {} // perfect match
     else if (isSubclassOf(a, c)) ++score;
     else return Integer.MAX_VALUE;
  }
  return score;
}




static <A extends AutoCloseable> A dm_ownResource(A resource) {
  dm_currentModuleMandatory().ownResource(resource);
  return resource;
}


static <A> AutoCloseable vmBus_onMessage(String msg, IVF1<A> onMessage) {
  return vmBus_onMessage(msg, ivf1ToVF1(onMessage));
}

static <A> AutoCloseable vmBus_onMessage(final String msg, final VF1<A> onMessage) {
  Map<String, Set> map = vm_busListenersByMessage_live();
  synchronized(map) {
    Set listeners = map.get(msg);
    if (listeners == null) map.put(msg, listeners = syncIdentityHashSet());
    // We're technically violating the one-synchronized-object-per-thread rule,
    // but it should be OK here.
    // TODO: remove empty sets from map
    return tempAdd(listeners, new VF2<String, Object>() { public void get(String _msg, Object arg) { try { 
      callF(onMessage, arg)
    ; } catch (Exception __e) { throw rethrow(__e); } }
  public String toString() { return "callF(onMessage, arg)"; }});
  }
}


static <A, B> AutoCloseable vmBus_onMessage(String msg, final VF2<A, B> onMessage) {
  return vmBus_onMessage(msg, new VF1<Object[]>() { public void get(Object[] o) { try { 
    callF(onMessage, first(o), second(o));
   } catch (Exception __e) { throw rethrow(__e); } }
  public String toString() { return "callF(onMessage, first(o), second(o));"; }});
}


static <A, B> AutoCloseable vmBus_onMessage(String msg, final IVF2<A, B> onMessage) {
  return vmBus_onMessage(msg, new VF1<Object[]>() { public void get(Object[] o) { try { 
    callF(onMessage, first(o), second(o));
   } catch (Exception __e) { throw rethrow(__e); } }
  public String toString() { return "callF(onMessage, first(o), second(o));"; }});
}





static AutoCloseable vmBus_onMessage(String msg, Runnable onMessage) {
  return vmBus_onMessage(msg, runnableToVF1(onMessage));
}


static 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 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 JButton onEnter(JButton btn, final Object action) {
  if (action == null || btn == null) return btn;
  btn.addActionListener(actionListener(action));
  return btn;
}

static JList onEnter(JList list, Object action) {
  list.addKeyListener(enterKeyListener(rCallOnSelectedListItem(list, action)));
  return list;
}

static 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 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 JTextArea onEnter(final JTextArea ta, fO action) {
  addKeyListener(ta, enterKeyListener(action));
  ret ta;
}*/

static JTextField onEnter(Runnable action, JTextField tf) {
  return onEnter(tf, action);
}


static String selectedItem(JList l) {
  return getSelectedItem(l);
}

static String selectedItem(JComboBox cb) {
  return getSelectedItem(cb);
}


static <A> List<A> replaceElementsUsingMap(Iterable<A> l, final Map<A, A> map) {
  return map(l, new F1<A, A>() { public A get(A a) { try {  return getOrKeep(map, a);  } catch (Exception __e) { throw rethrow(__e); } }
  public String toString() { return "getOrKeep(map, a)"; }});
}


static List<String> splitCamelCase(String s) {
  return ai_splitCamelCase(s);
}


static void addMenuItems(JMenu m, Object... x) {
  fillJMenu(m, x);
}

static void addMenuItems(JPopupMenu m, Object... x) {
  fillJPopupMenu(m, x);
}


static 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 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 boolean isChecked(JRadioButton rb) {
  return rb != null && (boolean) swing(() -> rb.isSelected());
}


static JTextField jTextField() {
  return jTextField("");
}

static JTextField jTextField(final String text) {
  return swing(new F0<JTextField>() { public JTextField get() { try { 
    JTextField tf = new JTextField(unnull(text));
    standardTextFieldPopupMenu(tf);
    jenableUndoRedo(tf);
    tf.selectAll();
    return tf;
   } catch (Exception __e) { throw rethrow(__e); } }
  public String toString() { return "JTextField tf = new JTextField(unnull(text));\r\n    standardTextFieldPopupMenu..."; }});
}

static JTextField jTextField(Object o) {
  return jTextField(strOrEmpty(o));
}



static JPanel showInternalFrameFormTitled(final JDesktopPane desktop, final String title, final Object... _parts) {
  JPanel panel = showForm_makePanel(true, _parts);
  showForm_makeInternalFrame(desktop, title, panel);
  return panel;
}


static  IVF2<String, JPanel> showForm_makeFrame;
static void showForm_makeFrame(String title, JPanel panel) { if (showForm_makeFrame != null) showForm_makeFrame.get(title, panel); else showForm_makeFrame_base(title, panel); }
final static void showForm_makeFrame_fallback(IVF2<String, JPanel> _f, String title, JPanel panel) { if (_f != null) _f.get(title, panel); else showForm_makeFrame_base(title, panel); }
static void showForm_makeFrame_base(String title, JPanel panel) {
  handleEscapeKey(minFrameWidth(showPackedFrame(title, withMargin(panel)), 400));
}


static List<JComponent> showForm_arrange1(List<List<JComponent>> l) {
  int minW = showForm_leftWidth(l);

  List<JComponent> out = new ArrayList();
  for (List<JComponent> row : l)
    out.add(westAndCenter(withRightMargin(showForm_gapBetweenColumns, jMinWidthAtLeast(minW, first(row))), second(row)));
  return out;
}


static List<List<JComponent>> showForm_makeComponents(Boolean internalFrame, Object... _parts) {
  IVF1<Component> closeFrame
    = isTrue(internalFrame)
      ? __1 -> disposeInternalFrame(__1)
    : isFalse(internalFrame)
      ? __2 -> disposeFrame(__2)
    : null;

  return showForm_makeComponents(closeFrame, _parts);
}

static List<List<JComponent>> showForm_makeComponents(IVF1<Component> closeFrame, Object... _parts) {

  List<List<JComponent>> l = new ArrayList();
  List parts = asList(_parts);
  JButton submitButton = null;
  
  for (int i = 0; i < l(parts); i++)
    if (parts.get(i) instanceof Swingable)
      parts.set(i, ((Swingable) parts.get(i)).visualize());
      
  for (int i = 0; i < l(parts); i++) {
    Object o = parts.get(i), next = get(parts, i+1);
    if (o instanceof String && next instanceof Component)
      setComponentID((Component) next, (String) o);
    
    if (o instanceof Component || o instanceof String || next instanceof Component) { // smartAdd accepts strings
      l.add(mapLL(__92 -> wrapForSmartAdd_jComponent(__92), 
          o == null ? new JPanel()
        : o instanceof String ? humanizeFormLabel((String) o)
        : o, next));
      if (next instanceof JButton && submitButton == null)
        submitButton = (JButton) next;
      i++;
    } else if (isRunnable(o))
      l.add(mapLL(__93 -> wrapForSmartAdd_jComponent(__93), null, submitButton = jbutton(showFormSubmitButtonName(), new Runnable() {  public void run() { try { 
        Object result = call(o);
        print("Result of form runnable: " + result + ". Button:  " + heldInstance(JButton.class));
        if (neq(Boolean.FALSE, result))
          { if (closeFrame != null) closeFrame.get(heldInstance(JButton.class)); }
      
} catch (Exception __e) { throw rethrow(__e); } }  public String toString() { return "Object result = call(o);\r\n        print(\"Result of form runnable: \" + result ..."; }})));
    else print("showForm: Unknown element type: " + getClassName(o));
  }
  if (submitButton != null) {
    final JButton _submitButton = submitButton;
    onEnterInAllTextFields(concatLists(l), new Runnable() {  public void run() { try {  clickButton(_submitButton) ;
} catch (Exception __e) { throw rethrow(__e); } }  public String toString() { return "clickButton(_submitButton)"; }});
  }
  
  // massage labels
  for (List<JComponent> row : l) {
    JComponent left = first(row);
    if (left instanceof JLabel) makeBold((JLabel) left).setVerticalAlignment(JLabel.TOP);
  }
  
  return l;
}


static int vstackWithSpacing_default = 10;

static JPanel vstackWithSpacing(final List parts) {
  return vstackWithSpacing(parts, vstackWithSpacing_default);
}

static 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); // well...
    smartAddWithLayout(panel, gbc, toObjectArray(nonNulls(parts)));
    //gbc = (GridBagConstraints) gbc.clone();
    //gbc.fill = GridBagConstraints.BOTH;
    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 JPanel vstackWithSpacing(Component... parts) {
  return vstackWithSpacing(asList(parts), vstackWithSpacing_default);
}

static JPanel vstackWithSpacing(int spacing, Component... parts) {
  return vstackWithSpacing(asList(parts), spacing);
}


static String getTextTrim(JTextComponent c) {
  return trim(getText(c));
}

// tested for editable combo box - returns the contents of text field
static String getTextTrim(JComboBox cb) {
  return trim(getText(cb));
}

static String getTextTrim(JComponent c) {
  if (c instanceof JLabel) return trim(((JLabel) c).getText());
  if (c instanceof JComboBox) return getTextTrim((JComboBox) c);
  return getTextTrim((JTextComponent) c);
}


static File toFile_nullOnEmpty(String s) {
  return empty(s) ? null : new File(s);
}


static JLabel jImageLabel(Image img) {
  return swingNu(JLabel.class, imageIcon(img));
}

static JLabel jImageLabel(javax.swing.Icon icon) {
  return swingNu(JLabel.class, icon);
}

static JLabel jImageLabel(String imageID) {
  return jImageLabel(imageIcon(imageID));
}

static 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 <A> Set<A> synchroWeakHashSet() {
  return Collections.newSetFromMap((Map) newWeakHashMap());
}


static boolean possibleGlobalID(String s) {
  return l(s) == globalIDLength() && allLowerCaseCharacters(s);
}


static String hdiv(Object contents, Object... params) {
  return hfulltag("div", contents, params);
}

static String hdiv() {
  return hdiv("");
}


static byte[] intToBytes(int i) {
  return new byte[] {
          (byte) (i >>> 24),
          (byte) (i >>> 16),
          (byte) (i >>> 8),
          (byte) i};
}




static boolean loadBufferedImage_useImageCache = true;

static 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();
          // fall back to loading from sourceforge
        }
    }
  
    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"));
      //Log.info("Cached image.");
    }
  
    //Log.info("Loaded image.");
    return image;
  } else
    return loadBufferedImage(new File(snippetIDOrURLOrFile));
} catch (Exception __e) { throw rethrow(__e); } }

static BufferedImage loadBufferedImage(File file) {
  return loadBufferedImageFile(file);
}


static Throwable printStackTrace2(Throwable e) {
  // we go to system.out now - system.err is nonsense
  print(getStackTrace2(e));
  return e;
}

static void printStackTrace2() {
  printStackTrace2(new Throwable());
}

static void printStackTrace2(String msg) {
  printStackTrace2(new Throwable(msg));
}



static Throwable innerException(Throwable e) {
  return getInnerException(e);
}


static 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 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 Map<String, java.util.regex.Pattern> compileRegexpIC_cache = syncMRUCache(10);

static 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 boolean regexpICMatches(String pat, String s) {
  return regexpIC(pat, s).matches();
}

static boolean regexpICMatches(Pattern pat, String s) {
  return pat.matcher(s).matches();
}


static List<String> jsonTok(String s) {
  List<String> tok = new ArrayList();
  int l = l(s);
  
  int i = 0;
  while (i < l) {
    int j = i;
    char c; String cc;
    
    // scan for whitespace
    while (j < l) {
      c = s.charAt(j);
      cc = s.substring(j, Math.min(j+2, l));
      if (c == ' ' || c == '\t' || c == '\r' || c == '\n')
        ++j;
      else if (cc.equals("/*")) {
        do ++j; while (j < l && !s.substring(j, Math.min(j+2, l)).equals("*/"));
        j = Math.min(j+2, l);
      } else if (cc.equals("//")) {
        do ++j; while (j < l && "\r\n".indexOf(s.charAt(j)) < 0);
      } else
        break;
    }
    
    tok.add(s.substring(i, j));
    i = j;
    if (i >= l) break;
    c = s.charAt(i); // cc is not needed in rest of loop body

    // scan for non-whitespace (json strings, "null" identifier, numbers. everything else automatically becomes a one character token.)
    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.isLetter(c))
      do ++j; while (j < l && Character.isLetter(s.charAt(j)));
    else if (Character.isDigit(c))
      do ++j; while (j < l && Character.isDigit(s.charAt(j)));
    else
      ++j;

    tok.add(s.substring(i, j));
    i = j;
  }
  
  if ((tok.size() % 2) == 0) tok.add("");
  return tok;
}



static Number boxedIntOrLong(long l) {
  return l != (int) l ? boxed(l) : boxed((int) l);
}


static boolean isConceptFieldIndexed(Class<? extends Concept> c, String field) {
  return isConceptFieldIndexed(db_mainConcepts(), c, field);
}

static boolean isConceptFieldIndexed(Concepts concepts, Class<? extends Concept> c, String field) {
  return concepts.getFieldIndex(c, field) != null;
}


static void dm_watchField(String field, Runnable onChange) {
  new Dyn_FieldWatcher(dm_current_mandatory(), field, onChange);
}


static void dm_watchFields(Collection<String> fields, Runnable onChange) {
  for (String field : unnullForIteration(fields))
    dm_watchField(field, onChange);
}


static void dm_reloadModuleInBackground(Object module) {
  dm_callOS("reloadModuleInBackground", dm_getStem(module));
}

static void dm_reloadModuleInBackground() {
  dm_reloadModuleInBackground(dm_current_mandatory_generic());
}


static boolean isURL(String s) {
  return startsWithOneOf(s, "http://", "https://", "file:");
}


static File imageSnippetCacheFile(String snippetID) {
  File dir = imageSnippetsCacheDir();
  
  if (!loadBufferedImage_useImageCache) return null;
  
  return new File(dir, parseSnippetID(snippetID) + ".png");
}


static String snippetImageURL_noHttps(String snippetID) {
  return snippetImageURL_noHttps(snippetID, "png");
}

static 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 File getGlobalCache() {
  File file = new File(javaxCachesDir(), "Binary Snippets");
  file.mkdirs();
  return file;
}



static String dataSnippetLink(String snippetID) {
  long id = parseSnippetID(snippetID);
  if (id >= 1100000 && id < 1200000)
    return imageServerURL() + id;
  if (id >= 1200000 && id < 1300000) { // Woody files, actually
    String pw = muricaPassword();
    if (empty(pw)) throw fail("Please set 'murica password by running #1008829");
    return "https://botcompany.de/files/" + id + "?_pass=" + pw; // XXX, although it typically gets hidden when printing
  }
  return fileServerURL() + "/" + id /*+ "?_pass=" + muricaPassword()*/;
}


static void loadBinaryPageToFile(String url, File file) { try {
  print("Loading " + url);
  loadBinaryPageToFile(openConnection(new URL(url)), file);
} catch (Exception __e) { throw rethrow(__e); } }

static void loadBinaryPageToFile(URLConnection con, File file) { try {
  setHeaders(con);
  loadBinaryPageToFile_noHeaders(con, file);
} catch (Exception __e) { throw rethrow(__e); } }

static void loadBinaryPageToFile_noHeaders(URLConnection con, File file) { try {
  assertNotNull(file);
  File ftemp = new File(f2s(file) + "_temp");
  FileOutputStream buf = newFileOutputStream(mkdirsFor(ftemp));
  try {
    InputStream inputStream = con.getInputStream();
    long len = 0;
    try { len = con.getContentLength/*Long*/(); } 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 Object[] mapToParams(Map map) {
  return mapToObjectArray(map);
}


static Object[] unrollParams(Object[] params) {
  if (l(params) == 1 && params[0] instanceof Map)
    return mapToParams((Map) params[0]);
  return params;
}


static Object html_valueLessParam_cache;
static Object html_valueLessParam() { if (html_valueLessParam_cache == null) html_valueLessParam_cache = html_valueLessParam_load(); return html_valueLessParam_cache;}

static Object html_valueLessParam_load() {
  return new Object();
}


static String htmlQuote(String s) {
  return "\"" + htmlencode_forParams(s) + "\"";
}


static IterableIterator emptyIterableIterator_instance = new IterableIterator() {
  public Object next() { throw fail(); }
  public boolean hasNext() { return false; }
};

static <A> IterableIterator<A> emptyIterableIterator() {
  return emptyIterableIterator_instance; 
}


static <A> A unpackExceptionAs(Class<A> c, Throwable e) {
  return innerExceptionOfType(c, e);
}


static <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 Map<String, Font> loadFont_cached_cache = new HashMap();

static synchronized 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 Font loadFont_cached(String snippetID, float size) { try {
  return loadFont_cached(snippetID).deriveFont(size);
} catch (Exception __e) { throw rethrow(__e); } }


static float getSwingFontScale() {
  return or((Float) vm_generalMap_get("swingFontScale_value"), 1f);
}


static String localCourierFontName() {
  // determined this by trial & error
  return isLinux() ? "Courier" : "Courier New";
}


static TimeZone localTimeZone() {
  return getTimeZone(standardTimeZone());
  // TimeZone.getDefault()?
}


static String htmlencode2(String s) {
  return htmlencode_noQuotes(s);
}


static 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 Frame getAWTFrame(final Object _o) {
  return swing(new F0<Frame>() { public Frame get() { try { 
    Object o = _o;
    /*
    ifdef HaveProcessing
      if (o instanceof PApplet) o = ((PApplet) o).getSurface();
    endifdef
    */
    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 String[] asStringArray(Collection<String> c) {
  return toStringArray(c);
}

static String[] asStringArray(Object o) {
  return toStringArray(o);
}



static boolean isSubclassOf(Class a, Class b) {
  return isSubclass(a, b);
}


static DynModule dm_currentModuleMandatory() {
  return dm_current_mandatory();
}


static <A> VF1<A> ivf1ToVF1(IVF1<A> f) {
  return f == null ? null : new VF1<A>() { public void get(A a) { try {  f.get(a) ; } catch (Exception __e) { throw rethrow(__e); } }
  public String toString() { return "f.get(a)"; }};
}


static <A> AutoCloseable tempAdd(Collection<A> l, A a) {
  if (l == null || l.contains(a)) return null;
  l.add(a);
  return new tempAdd_undo(l, a);
}

static class tempAdd_undo<A> implements AutoCloseable , IFieldsToList{
  Collection<A> l;
  A a;
  tempAdd_undo() {}
  tempAdd_undo(Collection<A> l, A a) {
  this.a = a;
  this.l = l;}
  public String toString() { return shortClassName_dropNumberPrefix(this) + "(" + l + ", " + a + ")"; }public Object[] _fieldsToList() { return new Object[] {l, a}; }

  public void close() { try { l.remove(a); } catch (Exception __e) { throw rethrow(__e); } }
}

static AutoCloseable tempAdd(Container a, Component b) {
  if (a == null || b == null) return null;
  { return swing(() -> { 
    if (b.getParent() == a) return null;
    a.add(b);
    return () -> { swing(() -> { 
      if (b.getParent() == a)
        removeFromParent(b);
    }); };
  }); }
}


static <A> A third(List<A> l) {
  return _get(l, 2);
}

static <A> A third(Iterable<A> l) {
  if (l == null) return null;
  Iterator<A> it = iterator(l);
  for (int _repeat_0 = 0; _repeat_0 < 2; _repeat_0++)  {
    if (!it.hasNext()) return null;
    it.next();
  }
  return it.hasNext() ? it.next() : null;
}


static <A> A third(Producer<A> p) {
  if (p == null) return null;
  for (int _repeat_1 = 0; _repeat_1 < 2; _repeat_1++)  {
    if (p.next() == null) return null;
  }
  return p.next();
}


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


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



static <A> VF1<A> runnableToVF1(final Runnable r) {
  return r == null ? null : new VF1<A>() { public void get(A a) { try {  r.run() ; } catch (Exception __e) { throw rethrow(__e); } }
  public String toString() { return "r.run()"; }};
}


static void clickButton(final JButton b) {
  if (b != null) { swing(() -> { 
    if (b.isEnabled())
      b.doClick();
  }); }
}


static KeyListener enterKeyListener(final Object action) {
  return new KeyAdapter() {
    public void keyPressed(KeyEvent ke) {
      if (ke.getKeyCode() == KeyEvent.VK_ENTER)
        pcallF(action);
    }
  };
}


static 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 String getSelectedItem(JList l) {
  return (String) l.getSelectedValue();
}

static String getSelectedItem(JComboBox cb) {
  return strOrNull(cb.getSelectedItem());
}


static <A> A getOrKeep(Map<A, ? extends A> map, A a) {
  if (map == null) return a;
  A v = map.get(a);
  return v != null ? v : a;
}


static List<String> ai_splitCamelCase(String s) {
  int j = 0;
  List<String> l = new ArrayList();
  
  // new addition
  if (isAllUpperCase(s)) { l.add(s); return l; }
  
  for (int i = 0; i < l(s); i++)
    if (i > j && isUpperCaseLetter(s.charAt(i))) {
      l.add(substring(s, j, i));
      j = i;
    }
  if (j < l(s))
    l.add(substring(s, j));
  return l;
}


static void fillJMenu(final JMenu m, Object... x) {
  //ifdef fillJMenu_debug
  //print("fillJMenu " + m);
  //endifdef
  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) // auto-skip separator if at top
        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); // "call" might use wrong method
    else if (o instanceof String || o instanceof Action || o instanceof Component)
      call(m, "add", o);
    else if (o == null && y instanceof Runnable)
      ++i; // text == null => disabled item
    else if (o != null)
      print("Unknown menu item: " + o);
  }
}


static 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); // "call" might use wrong method
    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 JTextField standardTextFieldPopupMenu(final JTextField tf) {
  final WeakReference<JTextField> ref = weakRef(tf);
  componentPopupMenuItem(tf, "Copy text to clipboard", new Runnable() {  public void run() { try { 
    copyTextToClipboard(ref.get().getText())
  ;
} catch (Exception __e) { throw rethrow(__e); } }  public String toString() { return "copyTextToClipboard(ref.get().getText())"; }});
  componentPopupMenuItem(tf, "Paste", new Runnable() {  public void run() { try {  ref.get().paste() ;
} catch (Exception __e) { throw rethrow(__e); } }  public String toString() { return "ref.get().paste()"; }});
  return tf;
}




static <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 JInternalFrame showForm_makeInternalFrame(JDesktopPane desktop, String title, JPanel panel) {
  JInternalFrame f = addInternalFrame(desktop, title, withMargin(panel));
  minInternalFrameWidth(f, 400);
  packInternalFrameVertically(f);
  centerInternalFrame(f);
  // TODO: handleEscapeKey(f);
  return f;
}


static JFrame handleEscapeKey(final JFrame frame) {
  KeyStroke stroke = KeyStroke.getKeyStroke(KeyEvent.VK_ESCAPE, 0);
  frame.getRootPane().registerKeyboardAction(new ActionListener() {
    public void actionPerformed(ActionEvent actionEvent) {
      frame.dispose();
    }
  }, stroke, JComponent.WHEN_IN_FOCUSED_WINDOW);
  return frame;
}



static JFrame minFrameWidth(JFrame frame, int w) {
  if (frame != null && frame.getWidth() < w)
    frame.setSize(w, frame.getHeight());
  return frame;
}

static JFrame minFrameWidth(int w, JFrame frame) {
  return minFrameWidth(frame, w);
}



static JFrame showPackedFrame(String title, Component contents) {
  return packFrame(showFrame(title, contents));
}

static JFrame showPackedFrame(Component contents) {
  return packFrame(showFrame(contents));
}


static int withMargin_defaultWidth = 6;

static JPanel withMargin(Component c) {
  return withMargin(withMargin_defaultWidth, c);
}

static JPanel withMargin(int w, Component c) {
  return withMargin(w, w, c);
}

static JPanel withMargin(int w, int h, Component c) {
  return withMargin(w, h, w, h, c);
}

static 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 int showForm_leftWidth_safetyMargin = 10;

static int showForm_leftWidth(List<List<JComponent>> l) {
  forEachLevel2(l, x -> vmBus_send("updateLayoutNow", x));
  int minW = 0;
  for (List<JComponent> row : l)
    minW = max(minW, getMinimumSize(first(row)).width);
  return minW + or((Integer) vmBus_query("formSafetyMargin"), showForm_leftWidth_safetyMargin);
}


static 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 int withRightMargin_defaultWidth = 6;

static JPanel withRightMargin(Component c) {
  return withRightMargin(withRightMargin_defaultWidth, c);
}

static 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 <A extends Component> A jMinWidthAtLeast(int w, final A c) {
  if (c == null) return null;
  return swing(new F0<A>() { public A get() { try { 
    Dimension size = c.getMinimumSize();
    Dimension d = new Dimension(max(w, size.width), size.height);
    c.setMinimumSize(d);
    return jPreferWidth(d.width, c);
   } catch (Exception __e) { throw rethrow(__e); } }
  public String toString() { return "Dimension size = c.getMinimumSize();\r\n    Dimension d = new Dimension(max(w, ..."; }});
}


static void disposeInternalFrame(Component c) {
  final JInternalFrame f = getInternalFrame(c);
  if (f != null) { swing(() -> { 
    vmBus_send("disposingInternalFrame", f);
    f.dispose();
    // now illegal... setOpt(f, lastFocusOwner := null); // Help GC
  }); }
}


static void disposeFrame(final Component c) {
  disposeWindow(c);
}


static void setComponentID(Component c, String id) {
  if (c != null) componentID_map.put(c, id);
}


static List mapLL(Object f, Object... data) {
  return map(f, ll(data));
}

static <A, B> List<B> mapLL(IF1<A, B> f, A... data) {
  return map(f, ll(data));
}


static JComponent wrapForSmartAdd_jComponent(Object o) {
  return componentToJComponent(wrapForSmartAdd(o));
}


static boolean isRunnable(Object o) {
  return o instanceof Runnable || hasMethod(o, "get");
}


static JButton jbutton(String text, Runnable action) {
  return newButton(text, action);
}

static JButton jbutton(String text, Object action) {
  return newButton(text, action);
}

// button without action
static JButton jbutton(String text) {
  return newButton(text, null);
}

/*static JButton jbutton(BufferedImage img, O action) {
  ret setButtonImage(img, jbutton("", action));
}*/

static JButton jbutton(Action action) {
  return swingNu(JButton.class, action);
}


static String showFormSubmitButtonName() {
  return "Submit";
}


static <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 void onEnterInAllTextFields(JComponent c, Runnable action) {
  if (action == null) return;
  for (Component tf : allChildren(c))
    onEnterIfTextField(tf, action);
}

static void onEnterInAllTextFields(List c, Runnable action) {
  for (Object o : unnull(c))
    if (o instanceof JComponent)
      onEnterInAllTextFields(((JComponent) o), action);
}


static <A extends JComponent> A makeBold(final A c) {
  if (c != null) { swing(() -> {  c.setFont(c.getFont().deriveFont(java.awt.Font.BOLD)); }); }
  return c;
}


static JPanel smartAddWithLayout(JPanel panel, Object layout, List parts) {
  for (Object o : parts)
    panel.add(wrapForSmartAdd(o), layout);
  return panel;
}

static JPanel smartAddWithLayout(JPanel panel, Object layout, Object... parts) {
  return smartAddWithLayout(panel, layout, asList(flattenArray2(parts)));
}



static <A> List<A> nonNulls(Iterable<A> l) {
  return withoutNulls(l);
}

static <A> List<A> nonNulls(A[] l) {
  return withoutNulls(l);
}

static <A, B> Map<A, B> nonNulls(Map<A, B> map) {
  return withoutNulls(map);
}

static <A, B> List<B> nonNulls(Iterable<A> l, IF1<A, B> f) {
  return mapNonNulls(l, f);
}


static Component jrigid() {
  return javax.swing.Box.createRigidArea(new Dimension(0, 0));
}


static int imageIcon_cacheSize = 10;
static boolean imageIcon_verbose = false;
static Map<String, ImageIcon> imageIcon_cache;
static Lock imageIcon_lock = lock();
static ThreadLocal<Boolean> imageIcon_fixGIF = new ThreadLocal();

// not going through BufferedImage preserves animations
static 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); // move to front of cache on access
  imageIcon_cache.put(imageID, ii);
  return ii;
} finally { unlock(__0); } } catch (Exception __e) { throw rethrow(__e); } }

// doesn't fix GIFs
static ImageIcon imageIcon(File f) { try {
  return new ImageIcon(f.toURI().toURL());
} catch (Exception __e) { throw rethrow(__e); } }

static ImageIcon imageIcon(Image img) {
  return img == null ? null : new ImageIcon(img);
}


  static ImageIcon imageIcon(RGBImage img) {
    return imageIcon(img.getBufferedImage());
  }



static int globalIDLength() {
  return 16;
}


static boolean allLowerCaseCharacters(String s) {
  for (int i = 0; i < l(s); i++)
    if (Character.getType(s.charAt(i)) != Character.LOWERCASE_LETTER) return false;
  return true;
}




static Map<Component, String> componentID_map = weakHashMap();

static String componentID(Component c) {
  return c == null ? null : componentID_map.get(c);
}


static BufferedImage imageIO_readURL(String url) { try {
  return ImageIO.read(new URL(url));
} catch (Exception __e) { throw rethrow(__e); } }



static File imageSnippetsCacheDir() {
  return javaxCachesDir("Image-Snippets");
}


static String snippetImageURL_http(String snippetID) {
  return snippetImageURL_http(snippetID, "png");
}

static String snippetImageURL_http(String snippetID, String contentType) {
  return replacePrefix("https://", "http://", snippetImageURL(snippetID, contentType)).replace(":8443", ":8080");
}


static BufferedImage loadBufferedImageFile(File file) { try {
  if (!isFile(file)) return null;
  
  return ImageIO.read(file);
} catch (Exception __e) { throw rethrow(__e); } }


static String getStackTrace2(Throwable e) {
  return hideCredentials(getStackTrace(unwrapTrivialExceptionWraps(e)) + replacePrefix("java.lang.RuntimeException: ", "FAIL: ",
    hideCredentials(str(innerException2(e)))) + "\n");
}


static 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 Matcher regexpIC(Pattern pat, String s) {
  return pat.matcher(unnull(s));
}

static Matcher regexpIC(String pat, String s) {
  return compileRegexpIC(pat).matcher(unnull(s));
}

static Pattern regexpIC(String pat) {
  return compileRegexpIC(pat);
}


static Integer boxed(int i) { return i; }
static Long boxed(long l) { return l; }


static String snippetImageURL(long snippetID) {
  return snippetImageURL(fsI(snippetID));
}

static String snippetImageURL(String snippetID) {
  return snippetImageURL(snippetID, "png");
}

static 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 = "http://eyeocr.sourceforge.net/filestore/filestore.php?cmd=serve&file=blob_" + id + "&contentType=image/" + contentType;
    url = "https://botcompany.de/img/" + id;
  return url;
}


static String fileServerURL() {
  return "https://botcompany.de/files";
}


public static File mkdirsFor(File file) {
  return mkdirsForFile(file);
}



static 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 File renameFile_assertTrue(File a, File b) { try {
  if (a.equals(b)) return b; // no rename necessary
  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 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 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 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 <A> Object[] mapToObjectArray(Collection<A> l, IF1<A, Object> f) {
  return mapToObjectArray(f, l);
}

static <A> Object[] mapToObjectArray(A[] l, IF1<A, Object> f) {
  return mapToObjectArray(f, l);
}

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


// this should be on by default now I think, but it may break
// legacy code...
static ThreadLocal<Boolean> htmlencode_forParams_useV2 = new ThreadLocal();

static 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 <A> A innerExceptionOfType(Class<A> c, Throwable e) {
  while  (true) { ping(); 
    if (e == null) return null;
    if (isInstanceOf(e, c))
      return (A) e;
    e = e.getCause();
  }
}


static <A extends JComponent> A bindToComponent(A component, Runnable onShow, Runnable onUnShow) {
  { swing(() -> { 
    final Var < Boolean > flag = new Var<>(false);
    component.addAncestorListener(new AncestorListener() {
      public void ancestorAdded(AncestorEvent event) {
        if (flag.get()) print("Warning: bindToComponent logic failure");
        flag.set(true);
        pcallF(onShow);
      }
  
      public void ancestorRemoved(AncestorEvent event) {
        if (!flag.get()) print("Warning: bindToComponent logic failure");
        flag.set(false);
        pcallF(onUnShow);
      }
  
      public void ancestorMoved(AncestorEvent event) {
      }
    });
    if (component.isShowing()) { // Hopefully this matches the AncestorListener logic
      flag.set(true);
      pcallF(onShow);
    }
  }); }
  return component;
}

static <A extends JComponent> A bindToComponent(A component, Runnable onShow) {
  return bindToComponent(component, onShow, null);
}

// passing a value from onShow to onUnShow
static <A extends JComponent, B> A bindToComponent(A component, IF0<B> onShow, IVF1<B> onUnShow) {
  Var<B> b = new Var();
  return bindToComponent(component,
    () -> b.set(onShow.get()),
    () -> { try { onUnShow.get(b.get()); } finally { b.set(null); } });
}



static Font loadFont(String snippetID) { try {
  return loadFont(snippetID, 12f);
} catch (Exception __e) { throw rethrow(__e); } }

static Font loadFont(InputStream in) { try {
  return Font.createFont(Font.TRUETYPE_FONT, in);
} catch (Exception __e) { throw rethrow(__e); } }

static Font loadFont(String snippetID, float fontSize) {
  return loadFont(loadLibrary(snippetID), fontSize);
}

static Font loadFont(File f, float fontSize) { try {
  return Font.createFont(Font.TRUETYPE_FONT, f).deriveFont(fontSize);
} catch (Exception __e) { throw rethrow(__e); } }

static Font loadFont(InputStream in, float fontSize) { try {
  return Font.createFont(Font.TRUETYPE_FONT, in).deriveFont(fontSize);
} catch (Exception __e) { throw rethrow(__e); } }


static Cache<Boolean> isLinux_cache = new Cache<>(() -> isLinux_load());
static boolean isLinux() { return isLinux_cache.get(); }

static Boolean isLinux_load() {
  return !isWindows() && !isMac() && !isAndroid();
}




static TimeZone getTimeZone(String name) {
  return TimeZone.getTimeZone(name);
}


static String standardTimeZone_name = "Europe/Berlin";

static String standardTimeZone() {
  return standardTimeZone_name;
}


static 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 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 void removeFromParent(final Component c) {
  if (c != null) { swing(() -> { 
    Container cc = c.getParent();
    if (cc != null) {
      cc.remove(c);
      revalidate(cc);
    }
  }); }
}


static boolean isAllUpperCase(String s) {
  return hasLettersAllUpperCase(s);
}


static boolean isUpperCaseLetter(char c) {
  return Character.isUpperCase(c);
}


static Object[] asArray(List l) {
  return toObjectArray(l);
}

static <A> A[] asArray(Class<A> type, List l) {
  return (A[]) l.toArray((Object[]) Array.newInstance(type, l.size()));
}


static boolean isMenuSeparatorIndicator(Object o) {
  return eqOneOf(o, "***", "---", "===", "");
}


static int menuItemCount(JMenu menu) {
  return menu == null ? 0 : swing(() -> menu.getItemCount());
}


static 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 String unCurlyBracket(String s) {
  return tok_unCurlyBracket(s);
}


static boolean isCurlyBracketed(String s) {
  return isCurlyBraced(s);
}


static <A extends JComponent> A setEnabled(A c, boolean enable) {
  if (c != null) { swing(() -> {  c.setEnabled(enable); }); }
  return c;
}

static <A extends JComponent> A setEnabled(boolean enable, A c) {
  return setEnabled(c, enable);
}

static void setEnabled(boolean enable, JComponent... l) {
  for (var c : unnullForIteration(l))
    setEnabled(c, enable);
}


static 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 void setMeta(IMeta o, Object key, Object value) {
  metaMapPut(o, key, value);
}

static void setMeta(Object o, Object key, Object value) {
  metaMapPut(o, key, value);
}


static ThreadLocal<Boolean> addInternalFrame_dontSelect = new ThreadLocal();
static ThreadLocal<Integer> addInternalFrame_layer = new ThreadLocal();
static ThreadLocal<Boolean> addInternalFrame_toBack = new ThreadLocal();

static JInternalFrame addInternalFrame(final JDesktopPane desktop, final String title, final int x, final int y, final int w, final int h) {
  return addInternalFrame(desktop, title, x, y, w, h, null);
}

static JInternalFrame addInternalFrame(final JDesktopPane desktop, final String title, final int x, final int y, final int w, final int h, final Component contents) {
  return addInternalFrame(desktop, title, rect(x, y, w, h), contents);
}

static JInternalFrame addInternalFrame(final JDesktopPane desktop, final String title, final Component contents) {
  return addInternalFrame(desktop, title, null, contents);
}

static JInternalFrame addInternalFrame(final JDesktopPane desktop, final String title, final Rect r, final Component contents) {
  final boolean dontSelect = isTrue(optParam(addInternalFrame_dontSelect));
  final boolean toBack = isTrue(optParam(addInternalFrame_toBack));
  final Integer layer = optParam(addInternalFrame_layer);
  return swing(new F0<JInternalFrame>() { public JInternalFrame get() { try { 
    JInternalFrame frame;
    if (contents instanceof JInternalFrame)
      frame = (JInternalFrame) contents;
    else {
      frame = jInternalFrame(title);
      setInternalFrameContents(frame, contents);
    }
    frame.setVisible(true);
    desktop.add(frame, layer);
    if (r != null)
      setBounds(frame, r);
    else
      internalFrameDefaultPosition(frame);
    if (dontSelect)
      if (toBack)
        frame.toBack();
      else
        frame.toFront();
    else
      frame.setSelected(true);
    return fixInternalFrame(frame);
   } catch (Exception __e) { throw rethrow(__e); } }
  public String toString() { return "JInternalFrame frame;\r\n    if (contents instanceof JInternalFrame)\r\n      fra..."; }});
}

static JInternalFrame addInternalFrame(JDesktopPane desktop, String title) {
  return addInternalFrame(desktop, title, jpanel());
}


static JInternalFrame minInternalFrameWidth(final JInternalFrame frame, final int w) {
  { swing(() -> { 
    if (frame != null && frame.getWidth() < w)
      frame.setSize(w, frame.getHeight());
  }); }
  return frame;
}

static JInternalFrame minInternalFrameWidth(int w, JInternalFrame frame) {
  return minInternalFrameWidth(frame, w);
}



static <A extends Component> A packInternalFrameVertically(A c) {
  return packInternalFrameVertically(-1, c);
}

static <A extends Component> A packInternalFrameVertically(int width, A c) {
  final JInternalFrame win = getInternalFrame(c);
  if (win == null) return c;
  final int w = width < 0 ? win.getWidth() : width;
  { swing(() -> { 
    win.pack();
    win.setSize(w, win.getHeight());
    fixInternalFrame(win);
  }); }
  return c;
}


static JInternalFrame centerInternalFrame(final JInternalFrame f) {
  { swing(() -> { 
    Container c = f.getParent();
    if (c != null) {
      //print("Container type: " + className(c) + ", bounds: " + c.getBounds());
      f.setLocation((c.getWidth()-f.getWidth())/2, (c.getHeight()-f.getHeight())/2);
    }
  }); }
  return f;
}

static JInternalFrame centerInternalFrame(final int w, final int h, final JInternalFrame f) {
  { swing(() -> { 
    f.setSize(w, h);
  }); }
  return centerInternalFrame(f);
}


static int packFrame_minw = 150, packFrame_minh = 50;

static <A extends Component> A packFrame(final A c) {
  { swing(() -> { 
    Window w = getWindow(c);
    if (w != null) {
      w.pack();
      int maxW = getScreenWidth()-50, maxH = getScreenHeight()-50;
      w.setSize(
        min(maxW, max(w.getWidth(), packFrame_minw)),
        min(maxH, max(w.getHeight(), packFrame_minh)));
    }
  }); }
  return c;
}

static JFrame packFrame(ButtonGroup g) {
  return packFrame(getFrame(g));
}


static JFrame showFrame() {
  return makeFrame();
}

static JFrame showFrame(Object content) {
  return makeFrame(content);
}

static JFrame showFrame(String title) {
  return makeFrame(title);
}

static JFrame showFrame(String title, Object content) {
  return makeFrame(title, content);
}

static JFrame showFrame(final JFrame f) {
  if (f != null) { swing(() -> { 
    if (frameTooSmall(f)) frameStandardSize(f);
    if (!f.isVisible()) f.setVisible(true); // XXX
    if (f.getState() == Frame.ICONIFIED) f.setState(Frame.NORMAL);
  }); }
  return f;
}

// make or update frame
static JFrame showFrame(String title, Object content, JFrame frame) {
  if (frame == null)
    return showFrame(title, content);
  else {
    frame.setTitle(title);
    setFrameContents(frame, content);
    return frame;
  }
}


static JPanel marginPanel() {
  return jtransparent(borderLayoutPanel());
}


static <A, B extends Collection<A>> void forEachLevel2(Iterable<B> l, IVF1<A> f) {
  if (l != null) for (B b : l)
    forEach(b, f);
}

static <A, B extends Collection<A>> void forEachLevel2(IVF1<A> f, Iterable<B> l) {
  forEachLevel2(f, l);
}


static 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 <A extends Component> A jPreferWidth(int w, A c) {
  { swing(() -> { 
    Dimension size = c.getPreferredSize();
    c.setPreferredSize(new Dimension(/*max(w, size.width) ??? */w, size.height));
  }); }
  return c;
}

static <A extends Component> A jPreferWidth(A c, int w) {
  return jPreferWidth(w, c);
}


static void disposeWindow(final Window window) {
  if (window != null) { swing(() -> { 
    window.dispatchEvent(new WindowEvent(window, WindowEvent.WINDOW_CLOSING)); // call listeners
    myFrames_list.remove(window);
    window.dispose();
  }); }
}

static void disposeWindow(final Component c) {
  disposeWindow(getWindow(c));
}

static void disposeWindow(Object o) {
  if (o != null) disposeWindow(((Component) o));
}

static void disposeWindow() {
  disposeWindow(heldInstance(Component.class));
}


static boolean hasMethod(Object o, String method, Object... args) {
  return findMethod_cached(o, method, args) != null;
}


static boolean newButton_autoToolTip = true;

static boolean newButton_autoToolTip() { return newButton_autoToolTip; }

// action can be Runnable or a function name
static 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());
      //onChangeAndNow(btn, r { btn.setToolTipText(btn.getText()) });
    }
    // submitButtonOnEnter(btn); // test this first
    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 boolean isInstanceOf(Object o, Class type) {
  return type.isInstance(o);
}


static List<Component> allChildren(Component c) {
  return childrenOfType(c, Component.class);
}


static void onEnterIfTextField(Component c, Runnable action) {
  if (action == null) return;
  if (c instanceof JTextField)
    onEnter(((JTextField) c), action);
  else if (c instanceof JComboBox)
    onEnter(((JComboBox) c), action);
}


static <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 <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 <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 List mapNonNulls(Iterable l, Object f) { return mapNonNulls(f, l); }

static List mapNonNulls(Object f, Iterable l) {
  List x = new ArrayList();
  if (l != null) for (Object o : l)
    addIfNotNull(x, callF(f, o));
  return x;
}

static List mapNonNulls(Object f, Object[] l) {
  List x = new ArrayList();
  if (l != null) for (Object o : l)
    addIfNotNull(x, callF(f, o));
  return x;
}


  static <A, B> List<B> mapNonNulls(Iterable<A> l, F1<A, B> f) { return mapNonNulls(f, l); }

  static <A, B> List<B> mapNonNulls(F1<A, B> f, Iterable<A> l) {
    List x = new ArrayList();
    if (l != null) for (Object o : l)
      addIfNotNull(x, callF(f, o));
    return x;
  }


static <A, B> List<B> mapNonNulls(A[] l, IF1<A, B> f) {
  return mapNonNulls(f, l);
}

static <A, B> List<B> mapNonNulls(Iterable<A> l, IF1<A, B> f) {
  List x = emptyList(l);
  if (l != null) for (A o : l)
    addIfNotNull(x, f.get(o));
  return x;
}

static <A, B> List<B> mapNonNulls(IF1<A, B> f, Iterable<A> l) {
  return mapNonNulls(l, f);
}







static boolean loadBufferedImageFixingGIFs_debug = false;
static ThreadLocal<Var<byte[]>> loadBufferedImageFixingGIFs_output = new ThreadLocal();

static Image loadBufferedImageFixingGIFs(File file) { try {
  if (!file.exists()) return null;

  // Load anything but GIF the normal way
  if (!isGIF(file))
    return ImageIO.read(file);
    
  if (loadBufferedImageFixingGIFs_debug) print("loadBufferedImageFixingGIFs" + ": checking gif");

  // Get GIF reader
  ImageReader reader = ImageIO.getImageReadersByFormatName("gif").next();
  // Give it the stream to decode from
  reader.setInput(ImageIO.createImageInputStream(file));

  int numImages = reader.getNumImages(true);

  // Get 'metaFormatName'. Need first frame for that.
  IIOMetadata imageMetaData = reader.getImageMetadata(0);
  String metaFormatName = imageMetaData.getNativeMetadataFormatName();

  // Find out if GIF is bugged
  boolean foundBug = false;
  for (int i = 0; i < numImages && !foundBug; i++) {
      // Get metadata
      IIOMetadataNode root = (IIOMetadataNode)reader.getImageMetadata(i).getAsTree(metaFormatName);

      // Find GraphicControlExtension node
      int nNodes = root.getLength();
      for (int j = 0; j < nNodes; j++) {
          org.w3c.dom.Node node = root.item(j);
          if (node.getNodeName().equalsIgnoreCase("GraphicControlExtension")) {
              // Get delay value
              String delay = ((IIOMetadataNode)node).getAttribute("delayTime");

              // Check if delay is bugged
              if (Integer.parseInt(delay) == 0) {
                  foundBug = true;
              }

              break;
          }
      }
  }

  if (loadBufferedImageFixingGIFs_debug) print("loadBufferedImageFixingGIFs" + ": " + f2s(file) + " foundBug=" + foundBug);
  
  // Load non-bugged GIF the normal way
  Image image;
  if (!foundBug) {
    image = Toolkit.getDefaultToolkit().createImage(f2s(file));
  } else {
    // Prepare streams for image encoding
    ByteArrayOutputStream baoStream = new ByteArrayOutputStream();
    {
       ImageOutputStream ios = ImageIO.createImageOutputStream(baoStream); try {
      // Get GIF writer that's compatible with reader
      ImageWriter writer = ImageIO.getImageWriter(reader);
      // Give it the stream to encode to
      writer.setOutput(ios);

      writer.prepareWriteSequence(null);

      for (int i = 0; i < numImages; i++) {
          // Get input image
          BufferedImage frameIn = reader.read(i);

          // Get input metadata
          IIOMetadataNode root = (IIOMetadataNode)reader.getImageMetadata(i).getAsTree(metaFormatName);

          // Find GraphicControlExtension node
          int nNodes = root.getLength();
          for (int j = 0; j < nNodes; j++) {
              org.w3c.dom.Node node = root.item(j);
              if (node.getNodeName().equalsIgnoreCase("GraphicControlExtension")) {
                  // Get delay value
                  String delay = ((IIOMetadataNode)node).getAttribute("delayTime");

                  // Check if delay is bugged
                  if (Integer.parseInt(delay) == 0) {
                      // Overwrite with a valid delay value
                      ((IIOMetadataNode)node).setAttribute("delayTime", "10");
                  }

                  break;
              }
          }

          // Create output metadata
          IIOMetadata metadata = writer.getDefaultImageMetadata(new ImageTypeSpecifier(frameIn), null);
          // Copy metadata to output metadata
          metadata.setFromTree(metadata.getNativeMetadataFormatName(), root);

          // Create output image
          IIOImage frameOut = new IIOImage(frameIn, null, metadata);

          // Encode output image
          writer.writeToSequence(frameOut, writer.getDefaultWriteParam());
      }

      writer.endWriteSequence();
    } finally { _close(ios); }}

    // Create image using encoded data
    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 Map<JFrame, Boolean> myFrames_list = weakHashMap();

static 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 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 String multiLineQuoteWithSpaces(String s) {
  return multiLineQuote(" " + s + " ");
}


static String imageServerLink(String md5OrID) {
  if (possibleMD5(md5OrID))
    return "https://botcompany.de/images/md5/" + md5OrID;
  return imageServerLink(parseSnippetID(md5OrID));
}

static String imageServerLink(long id) {
  return "https://botcompany.de/images/" + id;
}


static 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 boolean isMac() {
    return System.getProperty("os.name").toLowerCase().contains("mac");
	}


static String intToHex_flexLength(int i) {
  return Integer.toHexString(i);
}


static boolean hasLettersAllUpperCase(String s) {
  return hasLetters(s) && !containsLowerCase(s);
}


static String tok_unCurlyBracket(String s) {
  return isCurlyBraced(s) ? join(dropFirstThreeAndLastThree(javaTok(s))) : s;
}


static boolean isCurlyBraced(String s) {
  List<String> tok = tok_combineCurlyBrackets_keep(javaTok(s));
  return l(tok) == 3 && startsWithAndEndsWith(tok.get(1), "{", "}");
}


static boolean jInternalFrame_iconifiable = true;

static JInternalFrame jInternalFrame() {
  return jInternalFrame("");
}

static JInternalFrame jInternalFrame(final String title) {
  return swing(new F0<JInternalFrame>() { public JInternalFrame get() { try { 
    JInternalFrame f = new JInternalFrame(title, true, true, true, jInternalFrame_iconifiable);
    f.setVisible(true);
    return f;
   } catch (Exception __e) { throw rethrow(__e); } }
  public String toString() { return "JInternalFrame f = new JInternalFrame(title, true, true, true, jInternalFrame..."; }});
}


static void setInternalFrameContents(final Component c, final Object contents) {
  { swing(() -> { 
    JInternalFrame frame = getInternalFrame(c);
    if (frame == null) return;
    frame.getContentPane().removeAll();
    frame.getContentPane().setLayout(new BorderLayout());
    if (contents != null) frame.getContentPane().add(wrap(contents));
    revalidate(frame);
  }); }
}


static <A extends Component> A setBounds(final int x, final int y, final int w, final int h, final A a) {
  if (a != null) { swing(() -> { 
    a.setBounds(x, y, w, h);
  }); }
  return a;
}

static <A extends Component> A setBounds(A a, Rect r) {
  if (a != null && r != null) { swing(() -> { 
    a.setBounds(toRectangle(r));
  }); }
  return a;
}

static <A extends Component> A setBounds(A a, Rectangle r) {
  if (a != null && r != null) { swing(() -> { 
    a.setBounds(r);
  }); }
  return a;
}

static <A extends Component> A setBounds(Rect r, A a) {
  return setBounds(a, r);
}

static <A extends Component> A setBounds(A a, int x, int y, int w, int h) {
  return setBounds(x, y, w, h, a);
}


static void internalFrameDefaultPosition(JInternalFrame f) {
  f.setSize(500, 300);
  centerInternalFrame(f);
}


static int fixInternalFrame_borderTopLeft = 0;
static int fixInternalFrame_borderBottomRight = 40; // for title bar

static JInternalFrame fixInternalFrame(final JInternalFrame f) {
  return swing(new F0<JInternalFrame>() { public JInternalFrame get() { try { 
    Container c = f.getParent();
    if (c == null) return f;
    Rect r = toRect(f.getBounds());
    int a = fixInternalFrame_borderTopLeft, b = fixInternalFrame_borderBottomRight;
    Rect outer = new Rect(a, a, c.getWidth()-b, c.getHeight()-b);
    if (!rectContains(outer, r))
      f.setLocation(
        max(a, min(r.x, outer.x2())),
        max(a, min(r.y, outer.y2())));
    if (r.w > c.getWidth() || r.h > c.getHeight())
      f.setSize(c.getWidth()-a, c.getHeight()-a);
    return f;
   } catch (Exception __e) { throw rethrow(__e); } }
  public String toString() { return "Container c = f.getParent();\r\n    if (c == null) ret f;\r\n    Rect r = toRect(..."; }});
}



static int getScreenWidth() {
  return getScreenSize().width;
}


static int getScreenHeight() {
  return getScreenSize().height;
}


static String makeFrame_defaultIcon;
static boolean makeFrame_hideConsole = false;
static ThreadLocal<VF1<JFrame>> makeFrame_post = new ThreadLocal();

static JFrame makeFrame() {
  return makeFrame((Component) null);
}

static JFrame makeFrame(Object content) {
  return makeFrame(programTitle(), content);
}

static JFrame makeFrame(String title) {
  return makeFrame(title, null);
}

static JFrame makeFrame(String title, Object content) {
  return makeFrame(title, content, true);
}

static 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);
    //callOpt(content, "requestFocus");
    //exitOnFrameClose(frame);
    
    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 boolean frameTooSmall(JFrame frame) {
  return frame.getWidth() < 100 || frame.getHeight() < 50;
}


static void frameStandardSize(JFrame frame) {
  frame.setBounds(300, 100, 500, 400);
}


static void setFrameContents(final Component c, final Object contents) { swing(() -> { 
  JFrame frame = getFrame(c);
  if (frame == null) return;
  frame.getContentPane().removeAll();
  frame.getContentPane().setLayout(new BorderLayout());
  frame.getContentPane().add(wrap(contents));
  revalidate(frame);
}); }


static <A extends JComponent> A jtransparent(final A a) {
  { swing(() -> {  a.setOpaque(false); }); }
  return a;
}


static JPanel borderLayoutPanel() {
  return jpanel(new BorderLayout());
}


static JButton basicJButton(String text) {
  return swing(() -> new JButton(text));
}


static <A> List<A> childrenOfType(Component c, Class<A> theClass) {
  List<A> l = new ArrayList();
  scanForComponents(c, theClass, l);
  return l;
}

static <A> List<A> childrenOfType(Class<A> theClass, Component c) {
  return childrenOfType(c, theClass);
}


static boolean containsNulls(Collection c) {
  return contains(c, null);
}


static Map similarEmptyMap(Map m) {
  if (m instanceof TreeMap) return new TreeMap(((TreeMap) m).comparator());
  if (m instanceof LinkedHashMap) return new LinkedHashMap();
  
  // default to a hash map
  return new HashMap();
}

static 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 byte[] isGIF_magic = bytesFromHex("47494638"); // Actual signature is longer, but we're lazy

static boolean isGIF(byte[] data) {
  return byteArrayStartsWith(data, isGIF_magic);
}

static boolean isGIF(File f) {
  return isGIF(loadBeginningOfBinaryFile(f, l(isGIF_magic)));
}


static <A> void setVar(IVar<A> v, A value) {
  if (v != null) v.set(value);
}

static <A> IVF1<A> setVar(IVar<A> v) {
  return a -> { if (v != null) v.set(a); };
}




static String multiLineQuote(String s) {
  for (int i = 0; ; i++) {
    String closer = "]" + rep('=', i) + "]";
    if (!contains(s, closer))
      return "[" + rep('=', i) + "[" + s + closer;
  }
}


static boolean possibleMD5(String s) { return isMD5(s); }


static boolean hasLetters(String s) {
  for (int i = 0; i < s.length(); i++)
    if (Character.isLetter(s.charAt(i)))
      return true;
  return false;
}


static boolean containsLowerCase(String s) {
  for (int i = 0; i < l(s); i++)
    if (isLowerCase(s.charAt(i)))
      return true;
  return false;
}


static <A> List<A> dropFirstThreeAndLastThree(List<A> l) {
  return dropFirstAndLast(3, l);
}


static 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 boolean startsWithAndEndsWith(String s, String prefix, String suffix) {
  return startsWith(s, prefix) && endsWith(s, suffix);
}


static Rectangle toRectangle(Rect r) {
  return r == null ? null : r.getRectangle();
}


static Dimension getScreenSize() {
  return Toolkit.getDefaultToolkit().getScreenSize();
}

static Dimension getScreenSize(int iScreen) {
  return toDimension(screenBounds(iScreen).widthAndHeight());
}


static String programTitle() {
  return getProgramName();
}


static 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 void _initFrame(JFrame f) {
  myFrames_list.put(f, Boolean.TRUE);
  standardTitlePopupMenu(f);
}


static Rectangle defaultNewFrameBounds_r = new Rectangle(300, 100, 500, 400);

static 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(bounds.x+30+random(30), bounds.y+20+random(20));
      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 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 <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 byte[] bytesFromHex(String s) {
  return hexToBytes(s);
}


static 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 byte[] loadBeginningOfBinaryFile(File file, int maxBytes) {
  return loadBinaryFilePart(file, 0, maxBytes);
}




static boolean isMD5(String s) {
  return l(s) == 32 && isLowerHexString(s);
}


static boolean isLowerCase(char c) {
  return Character.isLowerCase(c);
}


static <A> List<A> dropFirstAndLast(int n, List<A> l) {
  return cloneSubList(l, n, l(l)-n);
}

static <A> List<A> dropFirstAndLast(int m, int n, List<A> l) {
  return cloneSubList(l, m, l(l)-n);
}

static <A> List<A> dropFirstAndLast(List<A> l) {
  return dropFirstAndLast(1, l);
}

static String dropFirstAndLast(String s) {
  return substring(s, 1, l(s)-1);
}


// i must point at the (possibly imaginary) opening bracket
// index returned is index of closing bracket + 1
static 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 Dimension toDimension(WidthAndHeight wh) {
  return wh == null ? null : new Dimension(wh.getWidth(), wh.getHeight());
}


static Rect screenBounds(GraphicsDevice screen) {
  return screen == null ? null : toRect(screen.getDefaultConfiguration().getBounds());
}

static Rect screenBounds(int iScreen) {
  return screenBounds(get(screenDevices(), iScreen));
}


static void standardTitlePopupMenu(final JFrame frame) {
  // standard right-click behavior on titles
  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)"; }}));
    /*ifndef standardTitlePopupMenu_noShootWindow
      { menu.add(jMenuItem("Shoot Window", r { shootWindowGUI_external(frame, 500) })); }
    endifndef*/
    //addMenuItem(menu, "Bigger fonts", r swingBiggerFonts);
    //addMenuItem(menu, "Smaller fonts", r swingSmallerFonts);
   } catch (Exception __e) { throw rethrow(__e); } }
  public String toString() { return "bool alwaysOnTop = frame.isAlwaysOnTop();\r\n    ifndef standardTitlePopupMenu_..."; }});
}


static Rect preferredScreenBounds() {
  return screenBounds_safe(preferredScreen());
}


static Integer centerX(Rect r) {
  return rectCenterX(r);
}


static int random_incl(int min, int max) { return random_incl(min, max, defaultRandomizer()); }
static int random_incl(int min, int max, Random random) {
  return random(min, max+1, random);
}

static int random_incl(int max) {
  return random(0, max+1);
}


static Integer centerY(Rect r) {
  return rectCenterY(r);
}


static JFrame consoleFrame() {
  return (JFrame) getOpt(get(getJavaX(), "console"), "frame");
}


static void autoVMExit() {
  call(getJavaX(), "autoVMExit");
}


static byte[] loadBinaryFilePart(File file, long start, long end) { try {
  if (file == null) return null;
  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 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') {
      // ok
    } else
      return false;
  }
  return true;
}


static List<GraphicsDevice> screenDevices() {
  return asList(GraphicsEnvironment.getLocalGraphicsEnvironment().getScreenDevices());
}


static boolean isSubstanceLAF() {
  return substanceLookAndFeelEnabled();
}


// menuMaker = voidfunc(JPopupMenu)
// return true if menu could be added
static 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 void duplicateThisProgram() {
  nohupJavax(trim(programID() + " " + smartJoin((String[]) get(getJavaX(), "fullArgs"))));
}


static void showConsole() {
  callOpt(get(javax(), "console"), "showConsole");
}


static void toggleAlwaysOnTop(Window frame) {
  if (frame == null) return;
  { swing(() -> { 
    frame.setAlwaysOnTop(!frame.isAlwaysOnTop());
  }); }
}


static Rect screenBounds_safe(int iScreen) {
  return screenBounds(min(iScreen, screenCount()-1));
}


static  IF0<Integer> preferredScreen;
static int preferredScreen() { return preferredScreen != null ? preferredScreen.get() : preferredScreen_base(); }
final static int preferredScreen_fallback(IF0<Integer> _f) { return _f != null ? _f.get() : preferredScreen_base(); }
static int preferredScreen_base() {
  return 0;
}


static Integer rectCenterX(Rect r) {
  return r == null ? null : r.x+r.w/2;
}


static Integer rectCenterY(Rect r) {
  return r == null ? null : r.y+r.h/2;
}




static boolean substanceLookAndFeelEnabled() {
  return startsWith(getLookAndFeel(), "org.pushingpixels.");
}


static 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 /*SubstanceRootPaneUI*/ ui = rootPane.getUI();
		return (JComponent) call(ui, "getTitlePane");
	}
	return null;
}


// Try to get the quoting right...

static 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 String smartJoin(List<String> args) {
  return smartJoin(toStringArray(args));
}


static int screenCount() {
  return l(GraphicsEnvironment.getLocalGraphicsEnvironment().getScreenDevices());
}




static String getLookAndFeel() {
  return getClassName(UIManager.getLookAndFeel());
}


// supports the usual quotings (", variable length double brackets) except ' quoting
static boolean isQuoted(String s) {
  
  
  if (isNormalQuoted(s)) return true; // use the exact version
  
  return isMultilineQuoted(s);
}




static 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 boolean isMultilineQuoted(String s) {
  if (!startsWith(s, "[")) return false;
  int i = 1, n = s.length();
  while (i < n && s.charAt(i) == '=') ++i;
  return i < n && s.charAt(i) == '[';
}




static class Chain<A> implements Iterable<A> {
  A element;
  Chain<A> next;
  int size;
  
  Chain() {}
  Chain(A element) {
  this.element = element; size = 1; }
  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()); }
  
  ArrayList<A> toList() {
    ArrayList<A> l = emptyList(size);
    Chain<A> c = this;
    while (c != null) {
      l.add(c.element);
      c = c.next;
    }
    return l;
  }
  
  // TODO: optimize
  public Iterator<A> iterator() { return toList().iterator(); }
}
static class JSection extends SingleComponentPanel {
  JSection(Component c) { super(c); }
  
  String getTitle() {
    Border border = getBorder();
    if (border instanceof TitledBorder)
      return ((TitledBorder) border).getTitle();
    return null;
  }
}

// size:
// 64 bytes for 0 to 1 elements
// 96 bytes for 2 to 4 elements

/*
 * #!
 * Ontopia Engine
 * #-
 * Copyright (C) 2001 - 2013 The Ontopia Project
 * #-
 * Licensed under the Apache License, Version 2.0 (the "License");
 * you may not use this file except in compliance with the License.
 * You may obtain a copy of the License at
 * 
 *      http://www.apache.org/licenses/LICENSE-2.0
 * 
 * Unless required by applicable law or agreed to in writing, software
 * distributed under the License is distributed on an "AS IS" BASIS,
 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
 * See the License for the specific language governing permissions and
 * limitations under the License.
 * !#
 */

static class CompactHashMap<K, V> extends CompactAbstractMap<K, V> {
  final static int INITIAL_SIZE = 3;
  final static double LOAD_FACTOR = 0.6;

  // This object is used to represent a null KEY (null value are kept as is)
  final static Object nullObject = new Object();
  
  /**
   * When a key is deleted this object is put into the hashtable in
   * its place, so that other entries with the same key (collisions)
   * further down the hashtable are not lost after we delete an object
   * in the collision chain.
   */
  final static Object deletedObject = new Object();
  int elements;
  int freecells;
  Object[] table; // key, value, key, value, ...
  //int modCount;

  CompactHashMap() {
    this(INITIAL_SIZE);
  }

  CompactHashMap(int size) {
    table = new Object[(size==0 ? 1 : size)*2];
    elements = 0;
    freecells = tableSize();
    //modCount = 0;
  }
  
  // TODO: allocate smarter
  CompactHashMap(Map<K, V> map) {
    this(0);
    if (map != null) putAll(map);
  }

  // ===== MAP IMPLEMENTATION =============================================

  /**
   * Returns the number of key/value mappings in this map.
   */
  public synchronized int size() {
    return elements;
  }
  
  /**
   * Returns <tt>true</tt> if this map contains no mappings.
   */
  public synchronized boolean isEmpty() {
    return elements == 0;
  }

  /**
   * Removes all key/value mappings in the map.
   */
  public synchronized void clear() {
    elements = 0;
    for (int ix = 0; ix < tableSize(); ix++) {
      key(ix, null);
      value(ix, null);
    }
    freecells = tableSize();
    //modCount++;
  }
  
  /**
   * Returns <tt>true</tt> if this map contains the specified key.
   */
  public synchronized boolean containsKey(Object k) {
    return key(findKeyIndex(k)) != null;
  }
  
  /**
   * Returns <tt>true</tt> if this map contains the specified value.
   */
  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;
  }

  /**
   * Returns a read-only set view of the map's keys.
   */
  public synchronized Set<Entry<K, V>> entrySet() {
    return new EntrySet();
  }

  /**
   * Removes the mapping with key k, if there is one, and returns its
   * value, if there is one, and null if there is none.
   */
  public synchronized V remove(Object k) {
    int index = findKeyIndex(k);

    // we found the right position, now do the removal
    if (key(index) != null) {
      // we found the object

      // same problem here as with put
      V v = value(index);
      key(index, deletedObject);
      value(index, deletedObject);
      //modCount++;
      elements--;
      return v;
    } else
      // we did not find the key
      return null;
  }

  /**
   * Adds the specified mapping to this map, returning the old value for
   * the mapping, if there was one.
   */
  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;
    
    // search for the key (continue while !null and !this key)
    while(key(index) != null &&
          !(key(index).hashCode() == hash &&
            key(index).equals(k))) {

      // if there's a deleted mapping here we can put this mapping here,
      // provided it's not in here somewhere else already
      if (key(index) == deletedObject)
        deletedix = index;
      
      index = ((index + offset) & 0x7FFFFFFF) % tableSize();
      offset = offset*2 + 1;

      if (offset == -1)
        offset = 2;
    }
    
    if (key(index) == null) { // wasn't present already
      if (deletedix != -1) // reusing a deleted cell
        index = deletedix;
      else
        freecells--;

      //modCount++;
      elements++;

      key(index, k);
      value(index, v);
      
      // rehash with increased capacity
      if (1 - (freecells / (double) tableSize()) > LOAD_FACTOR)
        rehash(tableSize()*2 + 1);
      return null;
    } else { // was there already
      //modCount++;
      V oldv = value(index);
      value(index, v);
      return oldv;
    }
  }

  /**
   * INTERNAL: Rehashes the hashmap to a bigger size.
   */
  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;

      // search for the key
      while(newTable[index*2] != null) { // no need to test for duplicates
        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;
  }

  /**
   * Returns the value for the key k, if there is one, and null if
   * there is none.
   */
  public synchronized V get(Object k) {
    return value(findKeyIndex(k));
  }

  /**
   * Returns a virtual read-only collection containing all the values
   * in the map.
   */
  public synchronized Collection<V> values() {
    return new ValueCollection();
  }

  /**
   * Returns a virtual read-only set of all the keys in the map.
   */
  public synchronized Set<K> keySet() {
    return new KeySet();
  }

  // --- Internal utilities

  final int findKeyIndex(Object k) {
    if (k == null)
      k = nullObject;

    int hash = k.hashCode();
    int index = (hash & 0x7FFFFFFF) % tableSize();
    int offset = 1;

    // search for the key (continue while !null and !this key)
    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;
  }
  
  // --- Key set

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

  class KeyIterator<K> implements Iterator<K> {
    private int ix;
    
    private KeyIterator() {
      synchronized(CompactHashMap.this) {
        // walk up to first value, so that hasNext() and next() return
        // correct results
        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++);
      
      // walk up to next value
      for (; ix < tableSize(); ix++)
        if (key(ix) != null && key(ix) != deletedObject)
          break;
      
      // ix now either points to next key, or outside array (if no next)
      return key;
    }}
  }
  
  // --- Entry set
  
  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();
    }
  }

  class EntryIterator implements Iterator<Map.Entry<K, V>> {
    private int ix;
    
    private EntryIterator() {
      synchronized(CompactHashMap.this) {
        // walk up to first value, so that hasNext() and next() return
        // correct results
        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;
      
      // walk up to next value
      for (; ix < tableSize(); ix++)
        if (key(ix) != null && key(ix) != deletedObject)
          break;
      
      // ix now either points to next key, or outside array (if no next)
      return simpleMapEntry(key, val);
    }}
  }
  
  // --- Value collection

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

  class ValueIterator<V> implements Iterator<V> {
    private int ix;
    
    private ValueIterator() {
      synchronized(CompactHashMap.this) {
        // walk up to first value, so that hasNext() and next() return
        // correct results
        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++);
      
      // walk up to next value
      for (; ix < tableSize(); ix++)
        if (value(ix) != null && value(ix) != deletedObject)
          break;
      
      // ix now either points to next value, or outside array (if no next)
      return value;
    }}
  }
  
  K key(int i) { return (K) table[i*2]; }
  void key(int i, Object key) { table[i*2] = key; }
  V value(int i) { return (V) table[i*2+1]; }
  void value(int i, Object value) { table[i*2+1] = value; }
  
  int tableSize() { return table.length/2; }
}
// has equals semantics so passing it to onChange() etc is idempotent
static class UpdateTrigger implements Runnable , IFieldsToList{
  Updateable target;
  UpdateTrigger() {}
  UpdateTrigger(Updateable target) {
  this.target = target;}
  public String toString() { return shortClassName_dropNumberPrefix(this) + "(" + target + ")"; }

public boolean equals(Object o) {
if (!(o instanceof UpdateTrigger)) return false;
    UpdateTrigger __1 =  (UpdateTrigger) o;
    return eq(target, __1.target);
}

  public int hashCode() {
    int h = -1756880753;
    h = boostHashCombine(h, _hashCode(target));
    return h;
  }
  public Object[] _fieldsToList() { return new Object[] {target}; }

  public void run() { try { { if (target != null) target.update(); } } catch (Exception __e) { throw rethrow(__e); } }
}
static class DefunctClassLoader {}
static abstract class LiveValue<A> implements IF0WithChangeListeners<A> {
  abstract Class<A> getType();
  public abstract A get();
}
static class Dyn_FieldWatcher implements AutoCloseable {
  DynModule module;
  String field;
  Object value;
  Runnable action;
  
  Runnable changeListener = new Runnable() {  public void run() { try {  check(); 
} catch (Exception __e) { throw rethrow(__e); } }  public String toString() { return "check();"; }};
  VF1<String> fieldChangeListener = new VF1<String>() { public void get(String f) { try { 
    if (eq(f, field))
      check();
   } catch (Exception __e) { throw rethrow(__e); } }
  public String toString() { return "if (eq(f, field))\r\n      check();"; }};
  
  transient  IF1<Object, Object> cloneValue;
Object cloneValue(Object o) { return cloneValue != null ? cloneValue.get(o) : cloneValue_base(o); }
final Object cloneValue_fallback(IF1<Object, Object> _f, Object o) { return _f != null ? _f.get(o) : cloneValue_base(o); }
Object cloneValue_base(Object o) { return o; }
  
  Dyn_FieldWatcher(DynModule module, String field, Runnable action) {
    this(module, field, action, null);
  }
  
  Dyn_FieldWatcher(DynModule module, String field, Runnable action, IF1 cloneValue) {
  this.cloneValue = cloneValue;
  this.action = action;
  this.field = field;
  this.module = module;
    value = cloneValue(get(module, field));
    
    // Let's do both for safety
    module.onChange(changeListener);
    module.onFieldChange(fieldChangeListener);
  }
  
  void check() {
    Object newValue = cloneValue(get(module, field));
    if (eq(value, newValue)) return;
    value = newValue;
    dm_q(module, action);
  }
  
  public void close() { try {
    module.removeChangeListener(changeListener);
    module.removeFieldChangeListener(fieldChangeListener);
  } catch (Exception __e) { throw rethrow(__e); } }
}
static class IntVar {
  int a; // you can access this directly if you use one thread
  
  public synchronized void set(int v) {
    if (v != a) {
      a = v;
      notifyAll();
    }
  }
  
  public synchronized int get() { return a; }

  synchronized 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 class Complex implements IFieldsToList{
  static final String _fieldOrder = "re im";
  double re;
  double im;
  Complex() {}
  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}; }

  double abs() { return sqrt(re*re+im*im); }
  
  double re() { return re; }
  double im() { return im; }
  
  final double angle(){ return phase(); }
double phase() { return Math.atan2(im, re); }
  double fracAngle() { return fracNonNeg(angle()/twoPi()); } // angle as 0 to 1
  
  public String toString() {
    if (im != 0)
      return re == 0 ? im + "i" : re + plusPrefixUnlessMinus(str(im)) + "i";
    else
      return str(re);
  }
}
static class PopupMenuMaker {
   final public PopupMenuMaker setAllowScrolling(boolean allowScrolling){ return allowScrolling(allowScrolling); }
public PopupMenuMaker allowScrolling(boolean allowScrolling) { this.allowScrolling = allowScrolling; return this; }  final public boolean getAllowScrolling(){ return allowScrolling(); }
public boolean allowScrolling() { return allowScrolling; }
 boolean allowScrolling = true; // ignored when using existingMenu
   final public PopupMenuMaker setEvent(MouseEvent event){ return event(event); }
public PopupMenuMaker event(MouseEvent event) { this.event = event; return this; }  final public MouseEvent getEvent(){ return event(); }
public MouseEvent event() { return event; }
 MouseEvent event;
   final public PopupMenuMaker setPtInComponent(PtInComponent ptInComponent){ return ptInComponent(ptInComponent); }
public PopupMenuMaker ptInComponent(PtInComponent ptInComponent) { this.ptInComponent = ptInComponent; return this; }  final public PtInComponent getPtInComponent(){ return ptInComponent(); }
public PtInComponent ptInComponent() { return ptInComponent; }
 PtInComponent ptInComponent; // if different from event
   final public PopupMenuMaker setFillMenu(IVF1<JPopupMenu> fillMenu){ return fillMenu(fillMenu); }
public PopupMenuMaker fillMenu(IVF1<JPopupMenu> fillMenu) { this.fillMenu = fillMenu; return this; }  final public IVF1<JPopupMenu> getFillMenu(){ return fillMenu(); }
public IVF1<JPopupMenu> fillMenu() { return fillMenu; }
 IVF1<JPopupMenu> fillMenu;
   final public PopupMenuMaker setExistingMenu(JPopupMenu existingMenu){ return existingMenu(existingMenu); }
public PopupMenuMaker existingMenu(JPopupMenu existingMenu) { this.existingMenu = existingMenu; return this; }  final public JPopupMenu getExistingMenu(){ return existingMenu(); }
public JPopupMenu existingMenu() { return existingMenu; }
 JPopupMenu existingMenu;
   final public PopupMenuMaker setAddSeparator(boolean addSeparator){ return addSeparator(addSeparator); }
public PopupMenuMaker addSeparator(boolean addSeparator) { this.addSeparator = addSeparator; return this; }  final public boolean getAddSeparator(){ return addSeparator(); }
public boolean addSeparator() { return addSeparator; }
 boolean addSeparator = true; // add separator if existing meun

  JPopupMenu menu;
  
  PopupMenuMaker() {}
  PopupMenuMaker(MouseEvent event, IVF1<JPopupMenu> fillMenu) {
  this.fillMenu = fillMenu;
  this.event = event;}

  public void run() { swing(() -> { 
    if (existingMenu != null) {
      fix();
      var menu = existingMenu;
      int emptyCount = menu.getComponentCount();
      if (addSeparator)
        menu.addSeparator();
      int emptyCount2 = menu.getComponentCount();
      { if (fillMenu != null) fillMenu.get(menu); }
      if (menu.getComponentCount() == emptyCount2)
        truncateContainer(menu, emptyCount);
      //printVars("Extended popup menu", +emptyCount, +emptyCount2, n := menu.getComponentCount());
      packWindow(menu);
      //revalidate(menu);
    } else {
      JPopupMenu menu = new JPopupMenu();
      
      int emptyCount = menu.getComponentCount();
      { if (fillMenu != null) fillMenu.get(menu); }
      if (menu.getComponentCount() == emptyCount)
        return;
    
      if (allowScrolling) {
        menu = new JPopupMenu();
        JMenuScroller scroller = JMenuScroller.setScrollerFor(menu);
        scroller.fillMenu = toVF1(fillMenu);
      }
      
      if (ptInComponent == null) ptInComponent = ptInComponentFromEvent(event);
    
      if (hasParentOfType(JPopupMenu.class, ptInComponent.component)) {
        // component is in a menu itself. TODO: better positioning
        // Also this doesn't actually seem to work...
        menu.setInvoker(ptInComponent.component);
        menu.setVisible(true);
      } else
        menu.show(ptInComponent.component, ptInComponent.p.x, ptInComponent.p.y);
    }
  }); }
  
  static void fix() {
    JPopupMenu.setDefaultLightWeightPopupEnabled(false);
  }
}
static class HTTPSpamBlocker1 {
  Set<String> blockedIPs = expiringSet(10*60.0); // 10 minutes
  
  boolean isBadRequest(String uri, String ip) {
    return pairB(checkRequest(uri, ip));
  }
  
  // pair(count, bad)
  Pair<Integer, Boolean> checkRequest(String uri, String ip) {
    boolean bad = eq(uri, "/simulate-bad-client");
    Pair<Integer, Boolean> pair = simpleSpamClientDetect2(ip, uri);
    if (pair.b) {
      if (eq(ip, pcall_myFirewallIP()))
        print("Not blocking myself.");
      else {
        print("Blocking IP " + ip);
        blockedIPs.add(ip);
      }
    }
    
    if (blockedIPs.contains(ip)) {
      bad = true;
      print(t3("an HTTP request from a blocked IP", "came in at", dateWithTimeGMT()));
    }
    
    return pair(pair.a, bad);
  }
  
  void markNoSpam(String uri, String ip) {
    simpleSpamClientDetect2_markNoSpam(ip, uri);
  }
}
static class CountingOutputStream extends FilterOutputStream {
  long counter;
  
  CountingOutputStream(OutputStream out) { super(out); }
  
  @Override
  public void write(int b) throws IOException {
    ++counter;
    out.write(b);
  }

  @Override
  public void write(byte[] b) throws IOException {
    counter += b.length;
    out.write(b, 0, b.length);
  }

  @Override
  public void write(byte[] b, int off, int len) throws IOException {
    if (len == 0) return;
    counter += len;
    out.write(b, off, len);
  }
  
  long getFilePointer() { return counter; }
}
static class SingleComponentPanel extends JPanel {
  SingleComponentPanel() { super(new BorderLayout()); }

  SingleComponentPanel(Component component) {
    this();
    if (component != null) setComponent(component);
  }
  
  void set(Swingable component) {
    set(wrap(component));
  }

  final void set(Component component){ setComponent(component); }
void setComponent(Component component) {
    { swing(() -> { 
      if (getComponent() == component) return;
      
      removeAll();
      if (component != null)
        add(BorderLayout.CENTER, wrap(component));
      _revalidate(SingleComponentPanel.this);
    }); }
  }
  
  // Sometimes we need this?
  void setComponentAndRevalidateParent(Component component) {
    setComponent(component);
    _revalidate(_getParent(this));
  }
  
  final void clear(){ noComponent(); }
void noComponent() { setComponent(null); }
  
  final Component get(){ return getComponent(); }
Component getComponent() {
    return swing( () -> getComponentCount() == 0 ? null : getComponent(0));
  }
  
  boolean isEmpty() { return getComponent() == null; }
  boolean hasComponent() { return getComponent() != null; }
}
static class FixedRateTimer extends java.util.Timer implements AutoCloseable {
  FixedRateTimer() { this(false); }
  FixedRateTimer(boolean daemon) { this(defaultTimerName(), daemon); }
  FixedRateTimer(String name) { this(name, false); }
  FixedRateTimer(String name, boolean daemon) {
    super(name, daemon);
    _registerTimer(this);
  }
  
  List<Entry> entries = synchroList();
  
  static class Entry implements IFieldsToList{
  TimerTask task;
  long firstTime;
  long period;
  Entry() {}
  Entry(TimerTask task, long firstTime, long period) {
  this.period = period;
  this.firstTime = firstTime;
  this.task = task;}
  public String toString() { return shortClassName_dropNumberPrefix(this) + "(" + task + ", " + firstTime + ", " + period + ")"; }public Object[] _fieldsToList() { return new Object[] {task, firstTime, period}; }
}
  
  // Note: not all methods overridden; only use these ones
  
  public void scheduleAtFixedRate(TimerTask task, long delay, long period) {
    entries.add(new Entry(task, now()+delay, period));
    super.scheduleAtFixedRate(task, delay, period);
  }
  
  public void cancel() {
    entries.clear();
    super.cancel();
  }
  
  public int purge() {
    entries.clear();
    return super.purge();
  }
  
  FixedRateTimer changeRate(int newPeriod) {
    Object r = ((SmartTimerTask) first(entries).task).r;
    cancel();
    return doEvery(newPeriod, r);
  }
  
  public void close() { try { cancel(); } catch (Exception __e) { throw rethrow(__e); } }
}
// has equals semantics so passing it to onChange() etc is idempotent
static class ChangeTrigger implements Runnable , IFieldsToList{
  ChangeTriggerable target;
  ChangeTrigger() {}
  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 ThreadLocal<Map<String, String>> WebSocketHTTPD_headers = new ThreadLocal();
static ThreadLocal<WebSocketHTTPD> WebSocketHTTPD_current = new ThreadLocal();

static class WebSocketHTTPD extends NanoWebSocketServer {
  WebSocketHTTPD(int port, WebSocketFactory factory) {
    this(port, (Object) factory);
  }
  
  WebSocketHTTPD(String hostname, int port, WebSocketFactory factory) {
    super(hostname, port, webSocketFactory(factory));
    nanohttpd_socketTimeoutFix();
  }
    
  WebSocketHTTPD(int port, Object factory) {
    super(port, webSocketFactory(factory));
    nanohttpd_socketTimeoutFix();
  }

  // The following is all copied from #1011857 (replacing MyHTTPD* with WebSocketHTTPD*)
  
  Object onServe, onEndServe;
  volatile long requests;
  transient IF0<AutoCloseable> enter;
  //bool callMainClassServeFunction; // very old stuff
  
  Object serveFunction = new F2<String, Map<String, String>, Object>() { public Object get(String uri, Map<String, String> parms) { try { 
    return callHtmlMethod2(getMainClass(), uri, parms);
   } catch (Exception __e) { throw rethrow(__e); } }
  public String toString() { return "callHtmlMethod2(getMainClass(), uri, parms)"; }};
  
  static class Serving {
    String uri;
    Map<String, String> header, parms, files;
  }
  
  Set<Serving> currentlyServing = synchroSet();

  public Response serve(String uri, Method method,
    Map<String, String> header, Map<String, String> parms, Map<String, String> files) { try {
     AutoCloseable __1 = callF(enter); try {
    ++requests;
     AutoCloseable __2 = tempSetThreadLocal(WebSocketHTTPD_current, this); try {
    Serving serving = nu(Serving.class, "uri", uri, "header", header, "parms", parms, "files", files);
    currentlyServing.add(serving);
    pcallF(onServe, serving);
    try {
      String remoteAddr = getClientIPFromHeaders(header);
      String host = header.get("host");
      print(formatDateAndTime() + " Serving URI: " + quote((nempty(host) ? "//" + host : "") + uri) + " to: " + remoteAddr);
      
      /*if (nempty(remoteAddr) &&
        isTrue(callOpt(mc(), "isBlockedIP", remoteAddr))) {
        print("BLOCKED IP.");
        ret serve404();
      }*/
      
      try {
        /*if (callMainClassServeFunction) {
          virtual Response originalResponse = callOpt(getMainClass(), "serve", uri, method, header, parms, files);
          if (originalResponse != null && !originalResponse instanceof Response)
            fail("Bad response type for " + uri + ": " + className(originalResponse));
          Response response = cast originalResponse;
          if (response != null) ret response;
        }*/
        
        Object html;
        WebSocketHTTPD_headers.set(header);
        try {
          html = callF(serveFunction, uri, parms);
        } finally {
          WebSocketHTTPD_headers.set(null);
        }
        
        if (html != null) {
          if (html instanceof NanoHTTPD.Response)
            return ((NanoHTTPD.Response) html);
          else
            return serveHTML(strOrNull(html));
        }
        
        return serve404();
      } catch (Throwable e) {
        printStackTrace(e);
        return serveHTML("ERROR.");
      }
    } finally {
      pcallF(onEndServe, serving);
      currentlyServing.remove(serving);
    }
  } finally { _close(__2); }} finally { _close(__1); }} catch (Exception __e) { throw rethrow(__e); } }
}
static class T3<A, B, C> {
  A a;
  B b;
  C c;
  
  T3() {}
  T3(A a, B b, C c) {
  this.c = c;
  this.b = b;
  this.a = a;}
  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 boolean SimpleCRUD_searcher = true;

static class SimpleCRUD<A extends Concept> {
  Concepts concepts;
  Class<A> cc;
  JTable table;
  JPanel buttons, panel;
  Object renderer; // optional, func(A) -> Map
  Object sorter; // optional, func(Cl<Concept>) -> Cl<Concept>
  String hID = "ID";
  Set<String> unshownFields; // not shown in table or form
  Set<String> excludeFieldsFromEditing;
  String modifiedField; // field to hold last-modified timestamp
  TableSearcher tableSearcher;
  Set<String> multiLineFields; // string fields that should be shown as text areas
  Set<String> dontDuplicateFields;
  boolean latestFirst = false;
  int formFixer = 12; // stupid value to make submit button appear
  boolean editOnDoubleClick = true;
  boolean ensureIndexed = false;
  boolean showValuesAsStruct = false; // BREAKING CHANGE - used to be true

  SimpleCRUD(Class<A> cc) { this(db_mainConcepts(), cc); }
  SimpleCRUD(Concepts concepts, Class<A> cc) {
  this.cc = cc;
  this.concepts = concepts;}
  
  SimpleCRUD<A> show(String frameTitle) {
    make();
    showFrame(frameTitle, panel);
    return this;
  }
  
  SimpleCRUD<A> show() {
    return show(plural(shortClassName(cc)));
  }
  
  SimpleCRUD<A> showMaximized() { show(); maximizeFrame(panel); return this; }
  
  JPanel makePanel() { return make(); }
  JPanel make() {
    db();
    framesBot();
    return make_dontStartBots();
  }
  
  JPanel make_dontStartBots() {
    printVars("SimpleCRUD.make_dontStartBots", "concepts", concepts, "cc", cc, "count" , countConcepts(cc));
    if (ensureIndexed)
      indexConceptClass(concepts, cc);

    // next line not in swing part to allow passing arguments
    // from outside like showConceptsTable_afterUpdate
     AutoCloseable __1 = tempSetTL(showConceptsTable_concepts, concepts); try {
     AutoCloseable __2 = tempSetTL(showConceptsTable_latestFirst, latestFirst); try {
     AutoCloseable __3 = tempSetTL(showConceptsTable_sorter, sorter); try {
     AutoCloseable __4 = tempSetTL(showConceptsTable_dropFields, asList(unshownFields)); try {
     AutoCloseable __5 = tempSetTL(dataToTable_useStruct, showValuesAsStruct); try {
    table = makeConceptsTable(cc, wrapRenderer(renderer));
    { swing(() -> { 
      buttons = jRightAlignedLine(
        jbutton("Add...", new Runnable() {  public void run() { try {  newConcept() ;
} catch (Exception __e) { throw rethrow(__e); } }  public String toString() { return "newConcept()"; }}),
        tableDependButton(table, jbutton("Edit", new Runnable() {  public void run() { try { 
          editConcept(selectedConcept())
        ;
} catch (Exception __e) { throw rethrow(__e); } }  public String toString() { return "editConcept(selectedConcept())"; }})),
        tableDependButton(table, jbutton("Delete", new Runnable() {  public void run() { try { 
          final List<A> l = selectedConcepts();
          startThread("Delete concepts", new Runnable() {  public void run() { try {    
            withDBLock(concepts, new Runnable() {  public void run() { try {  for (A c : l) c.delete() ;
} catch (Exception __e) { throw rethrow(__e); } }  public String toString() { return "for (A c : l) c.delete()"; }});
          
} catch (Exception __e) { throw rethrow(__e); } }  public String toString() { return "withDBLock(concepts, new Runnable() {  public void run() { try {  for (A c : ..."; }});
        
} catch (Exception __e) { throw rethrow(__e); } }  public String toString() { return "final List<A> l = selectedConcepts();\r\n          thread \"Delete concepts\" {\r\n..."; }})),
        tableDependButton(table, jbutton("Duplicate...", new Runnable() {  public void run() { try { 
          duplicateConcept(selectedConcept())
        ;
} catch (Exception __e) { throw rethrow(__e); } }  public String toString() { return "duplicateConcept(selectedConcept())"; }})));
        
      if (SimpleCRUD_searcher) {
        tableSearcher = tableWithSearcher2(table, "withMargin" , true);
        panel = centerAndSouthWithMargin(tableSearcher.panel, withBottomMargin(buttons));
      } else
        panel = centerAndSouthWithMargin(table, withBottomMargin(buttons));
      
      Object fEdit = new VF1<Integer>() { public void get(Integer row) { try {  editConcept(conceptForRow(row)) ; } catch (Exception __e) { throw rethrow(__e); } }
  public String toString() { return "editConcept(conceptForRow(row))"; }};
      tablePopupMenuItem(table, "Edit...", fEdit);
      if (editOnDoubleClick)
        onDoubleClick(table, fEdit);
    }); }
    return panel;
  } finally { _close(__5); }} finally { _close(__4); }} finally { _close(__3); }} finally { _close(__2); }} finally { _close(__1); }}
  
  Object wrapRenderer(final Object renderer) {
    return renderer == null ? null : new F1<A, Object>() { public Object get(A a) { try { 
      return putAll(litorderedmap(hID, str(a.id)), (Map) callF(renderer, a));
     } catch (Exception __e) { throw rethrow(__e); } }
  public String toString() { return "putAll(litorderedmap(hID, str(a.id)), (Map) callF(renderer, a))"; }};
  }
  
  void newConcept() {
    duplicateConcept(null);
  }
    
  void duplicateConcept(A oldConcept) {
    final A c = unlisted(cc);
    ccopyFieldsExcept(oldConcept, c, dontDuplicateFields);
    final Map<String, JComponent> map = makeComponents(c);
    Runnable r = new Runnable() {  public void run() { try { 
      concepts.register(c);
      saveData(c, map);
    
} catch (Exception __e) { throw rethrow(__e); } }  public String toString() { return "concepts.register(c);\r\n      saveData(c, map);"; }};
     AutoCloseable __6 = tempSetMCOpt("formLayouter1_fixer2" , formFixer); try {
    showFormTitled2("New " + shortClassName(cc), arrayPlus(mapToObjectArray(map), r));
  } finally { _close(__6); }}

  void editConcept(final A c) {
    if (c == null) return;
    final Map<String, JComponent> map = makeComponents(c);
    Runnable r = new Runnable() {  public void run() { try {  saveData(c, map) ;
} catch (Exception __e) { throw rethrow(__e); } }  public String toString() { return "saveData(c, map)"; }};
     AutoCloseable __7 = tempSetMCOpt("formLayouter1_fixer2" , formFixer); try {
    showFormTitled2("Edit " + shortClassName(cc) + " #" + c.id, arrayPlus(mapToObjectArray(map), r));
  } finally { _close(__7); }}
  
  final A selectedConcept(){ return selected(); }
A selected() {
    return conceptForRow(selectedRow(table));
  }
  
  A conceptForRow(int row) {
    return (A) concepts.getConcept(toLong(getTableCell(table, row, 0)));
  }
  
  int indexOfConcept(final A c) {
    if (c == null) return -1;
    return swing(new F0<Integer>() { public Integer get() { try { 
      int n = tableRowCount(table);
      for (int row = 0; row < n; row++)
        if (toLong(getTableCell(table, row, 0)) == c.id)
          return row;
      return -1;
     } catch (Exception __e) { throw rethrow(__e); } }
  public String toString() { return "int n = tableRowCount(table);\r\n      for row to n:\r\n        if (toLong(getTab..."; }});
  }
  
  List<A> selectedConcepts() {
    return swing(() -> {
      int[] rows = table == null ? null : table.getSelectedRows();
      List<A> l = new ArrayList();
      for (int row : unnullForIteration(rows))
        l.add(conceptForRow(row));
      return l;
    });
  }
  
  Map<String, JComponent> makeComponents(A c) {
    Map<String, JComponent> map = litorderedmap();
    makeComponents(c, map);
    return map;
  }
  
  JComponent fieldComponent(A c, String field) {
    Class type = getFieldType(cc, field);
    Object value = getOpt(c, field);
    //print("Field type: " + field + " => " + type);
    if (type == boolean.class)
      return jCenteredCheckBox(isTrue(value));
    else if (contains(multiLineFields, field) || containsNewLines(optCast(String.class, value)))
      return typeWriterTextArea((String) value);
    else if (isSubtype(type, Concept.class))
      return jcomboboxFromConcepts_str(concepts, type, (Concept) value);
    
    else try {
      return autoComboBox(valueToString(value), new TreeSet<String>(map(__94 -> valueToString(__94), collect(list(concepts, cc), field))));
    } catch (Throwable e) {
      printException(e);
      return jTextField(valueToString(value));
    }
  }
  
  void saveComponent(A c, String field, JComponent comp) {
    comp = unwrap(comp);
    Class type = fieldType(c, field);
    
    if (comp instanceof JTextComponent)
      cset(c, field, convertToField(trimIf(!(comp instanceof JTextArea), getText((JTextComponent) comp)), cc, field));
    else if (comp instanceof JComboBox) {
      String text = getTextTrim((JComboBox) comp);
      if (isSubtype(type, Concept.class))
        cset(c, field, getConcept(concepts, parseFirstLong(text)));
      else
        cset(c, field, convertToField(text, cc, field));
    } else if (comp instanceof JCheckBox)
      cset(c, field, isChecked((JCheckBox) comp));
    
  }
  
  List<String> fields() {
    if (excludeFieldsFromEditing != null && modifiedField != null) excludeFieldsFromEditing.add(modifiedField);
    return listWithoutSet(filter(conceptFieldsInOrder(cc) , new F1<String, Boolean>() { public Boolean get(String field) { try {  return fieldType(cc, field) != Concept.Ref.class;  } catch (Exception __e) { throw rethrow(__e); } }
  public String toString() { return "fieldType(cc, field) != Concept.Ref.class"; }}),
      joinSets(excludeFieldsFromEditing, unshownFields));
  }
  
  void excludeFieldsFromEditing(String... fields) {
    excludeFieldsFromEditing = setPlus(excludeFieldsFromEditing, fields);
  }
  
  // override the following two methods to customize edit window
  
  void makeComponents(A c, Map<String, JComponent> map) {
    for (String field : fields())
      map.put(field, fieldComponent(c, field));
  }
  
  void saveData(A c, Map<String, JComponent> components) {
    for (String field : keys(components))
      saveComponent(c, field, components.get(field));
    if (modifiedField != null) cset(c, modifiedField, now());
  }
  
  JTable table() { return table; }
  
  transient  IF1<Object, String> valueToString;
String valueToString(Object o) { return valueToString != null ? valueToString.get(o) : valueToString_base(o); }
final String valueToString_fallback(IF1<Object, String> _f, Object o) { return _f != null ? _f.get(o) : valueToString_base(o); }
String valueToString_base(Object o) {
    return showValuesAsStruct
      ? structureOrText_crud(o)
      : strOrNull(o);
  }
} // end of SimpleCRUD
static class ConceptFieldIndex<A extends Concept, Val> extends ConceptFieldIndexBase<A, Val> {
  ConceptFieldIndex(Class<A> cc, String field) { super(cc, field); }
  ConceptFieldIndex(Concepts concepts, Class<A> cc, String field) { super(concepts, cc, field); }

  void init() {
    valueToObject = new MultiSetMap();
  }
  
  void register() {
    concepts.addFieldIndex(cc, field, this);
  }
}
static abstract class F2<A, B, C> {
  abstract C get(A a, B b);
}
static final class WidthAndHeightFinal extends Meta implements WidthAndHeight
   , IFieldsToList{
  static final String _fieldOrder = "width height";
  int width;
  int height;
  WidthAndHeightFinal() {}
  WidthAndHeightFinal(int width, int height) {
  this.height = height;
  this.width = width;}

public boolean equals(Object o) {
if (!(o instanceof WidthAndHeightFinal)) return false;
    WidthAndHeightFinal __0 =  (WidthAndHeightFinal) o;
    return width == __0.width && height == __0.height;
}

  public int hashCode() {
    int h = -1177452162;
    h = boostHashCombine(h, _hashCode(width));
    h = boostHashCombine(h, _hashCode(height));
    return h;
  }
  public Object[] _fieldsToList() { return new Object[] {width, height}; }

  public int getWidth() { return width; }
  public int getHeight() { return height; }
  
  WidthAndHeightFinal(int wAndH) { this(wAndH, wAndH); }
  
  public String toString() { return n2(width) + "*" + n2(height) + " px"; }
  
  
}
static class ReverseChain<A> implements Iterable<A> {
  A element;
  ReverseChain<A> prev;
  int size;
  
  ReverseChain() {}
  ReverseChain(ReverseChain<A> prev, A element) {
  this.element = element;
  this.prev = prev;
    if (prev == null) size = 1;
    else {
      prev.check();
      size = prev.size+1;
    }
  }
  
  void check() {
    if (size < 1) throw fail("You called the ReverseChain default constructor. Don't do that");
  }
  
  public String toString() {
    return str(toList());
  }
  
  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(); }
}
interface Updateable {
  void update();
}





static class SNIKeyManager implements X509KeyManager {
  Map<String, Pair<X509KeyManager, String>> keyManagersByDomain; // key = domain name, value = (key manager, alias)
  boolean verbose = false;

  SNIKeyManager(Map<String, Pair<X509KeyManager, String>> keyManagersByDomain) {
  this.keyManagersByDomain = keyManagersByDomain;}

  @Override
  public String[] getClientAliases(String keyType, Principal[] issuers) {
    throw printStackTrace(new UnsupportedOperationException());
  }

  @Override
  public String chooseClientAlias(String[] keyType, Principal[] issuers, Socket socket) {
    throw printStackTrace(new UnsupportedOperationException());
  }

  @Override
  public String[] getServerAliases(String keyType, Principal[] issuers) {
    return toStringArray(keys(keyManagersByDomain));
  }

  @Override
  public String chooseServerAlias(String keyType, Principal[] issuers, Socket socket) {
    // This is the one used by serveHttps right now
    ExtendedSSLSession session =  (ExtendedSSLSession) (((SSLSocket) socket).getHandshakeSession());
    if (verbose) print("chooseServerAlias session type: " + className(session));
    List<SNIServerName> names = session.getRequestedServerNames();
    if (verbose)
      print("Requested server names: " + names);
    String requestedName = str(first(names)); // rough, will look like this: "type=host_name (0), value=botcompany.de"
    requestedName = substring(requestedName, lastIndexOf(requestedName, "=")+1);
    
    for (String knownName : keys(keyManagersByDomain))
      //if (ewic(requestedName, knownName)) {
      if (domainIsUnder(requestedName, knownName)) {
        if (verbose) print("Matched server name: " + knownName);
        return knownName;
      }
        
    if (verbose)
      print("Reverting to default server name");
    return first(keys(keyManagersByDomain));
  }

  @Override
  public X509Certificate[] getCertificateChain(String alias) {
    X509KeyManager man; String alias2 ; Pair<X509KeyManager,String> __1= keyManagersByDomain.get(alias); man = __1.a; alias2 = __1.b;
    if (verbose) print("getCertificateChain " + alias + " => " + alias2);
    return man.getCertificateChain(alias2);
  }

  @Override
  public PrivateKey getPrivateKey(String alias) {
    X509KeyManager man; String alias2 ; Pair<X509KeyManager,String> __2= keyManagersByDomain.get(alias); man = __2.a; alias2 = __2.b;
    if (verbose) print("getPrivateKey " + alias + " => " + alias2);
    return man.getPrivateKey(alias2);
  }
}
static class Cache<A> {
  Object maker; // func -> A
  A value;
  long loaded;
  static boolean debug = false;
  long changeCount;
  Lock lock = lock();
  
  Cache() {}
  Cache(Object maker) {
  this.maker = maker;}
  Cache(IF0<A> maker) {
  this.maker = maker;}

  A get() {
    if (hasLock(lock)) return value; // Must be called from within maker
    Lock __0 = lock; lock(__0); try {
    if (loaded == 0) {
      value = make();
      changeCount++;
      loaded = sysNow();
    }
    return value;
  } finally { unlock(__0); } }

  void clear() {
    Lock __1 = lock; lock(__1); try {
    if (debug && loaded != 0)
      print("Clearing cache");
    value = null;
    changeCount++;
    loaded = 0;
  } finally { unlock(__1); } }

  // clear if older than x seconds
  // 0 does not do anything
  void clear(double seconds) {
    Lock __2 = lock; lock(__2); try {
    if (seconds != 0 && loaded != 0 && sysNow() >= loaded+seconds*1000)
      clear();
  } finally { unlock(__2); } }
  
  // override
  void set(A a) {
    Lock __3 = lock; lock(__3); try {
    value = a;
    ++changeCount;
    loaded = sysNow();
  } finally { unlock(__3); } }
  
  A make() {
    return (A) callF(maker);
  }
}


/**
 * A class that provides scrolling capabilities to a long menu dropdown or
 * popup menu.  A number of items can optionally be frozen at the top and/or
 * bottom of the menu.
 * <P>
 * <B>Implementation note:</B>  The default number of items to display
 * at a time is 15, and the default scrolling interval is 125 milliseconds.
 * <P>
 *
 * @version 1.5.0 04/05/12
 * @author Darryl
 * https://tips4java.wordpress.com/2009/02/01/menu-scroller/
 */
 


static class JMenuScroller {

  VF1<JPopupMenu> fillMenu;
  private JPopupMenu menu;
  private Component[] menuItems;
  private MenuScrollItem upItem;
  private MenuScrollItem downItem;
  private final MenuScrollListener menuListener = new MenuScrollListener();
  private int scrollCount;
  private int interval;
  private int topFixedCount;
  private int bottomFixedCount;
  private int firstIndex = 0;
  private int keepVisibleIndex = -1;

  /**
   * Registers a menu to be scrolled with the default number of items to
   * display at a time and the default scrolling interval.
   * 
   * @param menu the menu
   * @return the JMenuScroller
   */
  public static JMenuScroller setScrollerFor(JMenu menu) {
    return new JMenuScroller(menu);
  }

  /**
   * Registers a popup menu to be scrolled with the default number of items to
   * display at a time and the default scrolling interval.
   * 
   * @param menu the popup menu
   * @return the JMenuScroller
   */
  public static JMenuScroller setScrollerFor(JPopupMenu menu) {
    return new JMenuScroller(menu);
  }

  /**
   * Registers a menu to be scrolled with the default number of items to
   * display at a time and the specified scrolling interval.
   * 
   * @param menu the menu
   * @param scrollCount the number of items to display at a time
   * @return the JMenuScroller
   * @throws IllegalArgumentException if scrollCount is 0 or negative
   */
  public static JMenuScroller setScrollerFor(JMenu menu, int scrollCount) {
    return new JMenuScroller(menu, scrollCount);
  }

  /**
   * Registers a popup menu to be scrolled with the default number of items to
   * display at a time and the specified scrolling interval.
   * 
   * @param menu the popup menu
   * @param scrollCount the number of items to display at a time
   * @return the JMenuScroller
   * @throws IllegalArgumentException if scrollCount is 0 or negative
   */
  public static JMenuScroller setScrollerFor(JPopupMenu menu, int scrollCount) {
    return new JMenuScroller(menu, scrollCount);
  }

  /**
   * Registers a menu to be scrolled, with the specified number of items to
   * display at a time and the specified scrolling interval.
   * 
   * @param menu the menu
   * @param scrollCount the number of items to be displayed at a time
   * @param interval the scroll interval, in milliseconds
   * @return the JMenuScroller
   * @throws IllegalArgumentException if scrollCount or interval is 0 or negative
   */
  public static JMenuScroller setScrollerFor(JMenu menu, int scrollCount, int interval) {
    return new JMenuScroller(menu, scrollCount, interval);
  }

  /**
   * Registers a popup menu to be scrolled, with the specified number of items to
   * display at a time and the specified scrolling interval.
   * 
   * @param menu the popup menu
   * @param scrollCount the number of items to be displayed at a time
   * @param interval the scroll interval, in milliseconds
   * @return the JMenuScroller
   * @throws IllegalArgumentException if scrollCount or interval is 0 or negative
   */
  public static JMenuScroller setScrollerFor(JPopupMenu menu, int scrollCount, int interval) {
    return new JMenuScroller(menu, scrollCount, interval);
  }

  /**
   * Registers a menu to be scrolled, with the specified number of items
   * to display in the scrolling region, the specified scrolling interval,
   * and the specified numbers of items fixed at the top and bottom of the
   * menu.
   * 
   * @param menu the menu
   * @param scrollCount the number of items to display in the scrolling portion
   * @param interval the scroll interval, in milliseconds
   * @param topFixedCount the number of items to fix at the top.  May be 0.
   * @param bottomFixedCount the number of items to fix at the bottom. May be 0
   * @throws IllegalArgumentException if scrollCount or interval is 0 or
   * negative or if topFixedCount or bottomFixedCount is negative
   * @return the JMenuScroller
   */
  public static JMenuScroller setScrollerFor(JMenu menu, int scrollCount, int interval,
          int topFixedCount, int bottomFixedCount) {
    return new JMenuScroller(menu, scrollCount, interval,
            topFixedCount, bottomFixedCount);
  }

  /**
   * Registers a popup menu to be scrolled, with the specified number of items
   * to display in the scrolling region, the specified scrolling interval,
   * and the specified numbers of items fixed at the top and bottom of the
   * popup menu.
   * 
   * @param menu the popup menu
   * @param scrollCount the number of items to display in the scrolling portion
   * @param interval the scroll interval, in milliseconds
   * @param topFixedCount the number of items to fix at the top.  May be 0
   * @param bottomFixedCount the number of items to fix at the bottom.  May be 0
   * @throws IllegalArgumentException if scrollCount or interval is 0 or
   * negative or if topFixedCount or bottomFixedCount is negative
   * @return the JMenuScroller
   */
  public static JMenuScroller setScrollerFor(JPopupMenu menu, int scrollCount, int interval,
          int topFixedCount, int bottomFixedCount) {
    return new JMenuScroller(menu, scrollCount, interval,
            topFixedCount, bottomFixedCount);
  }

  /**
   * Constructs a <code>JMenuScroller</code> that scrolls a menu with the
   * default number of items to display at a time, and default scrolling
   * interval.
   * 
   * @param menu the menu
   */
  public JMenuScroller(JMenu menu) {
    this(menu, 15);
  }

  /**
   * Constructs a <code>JMenuScroller</code> that scrolls a popup menu with the
   * default number of items to display at a time, and default scrolling
   * interval.
   * 
   * @param menu the popup menu
   */
  public JMenuScroller(JPopupMenu menu) {
    this(menu, 15);
  }

  /**
   * Constructs a <code>JMenuScroller</code> that scrolls a menu with the
   * specified number of items to display at a time, and default scrolling
   * interval.
   * 
   * @param menu the menu
   * @param scrollCount the number of items to display at a time
   * @throws IllegalArgumentException if scrollCount is 0 or negative
   */
  public JMenuScroller(JMenu menu, int scrollCount) {
    this(menu, scrollCount, 150);
  }

  /**
   * Constructs a <code>JMenuScroller</code> that scrolls a popup menu with the
   * specified number of items to display at a time, and default scrolling
   * interval.
   * 
   * @param menu the popup menu
   * @param scrollCount the number of items to display at a time
   * @throws IllegalArgumentException if scrollCount is 0 or negative
   */
  public JMenuScroller(JPopupMenu menu, int scrollCount) {
    this(menu, scrollCount, 150);
  }

  /**
   * Constructs a <code>JMenuScroller</code> that scrolls a menu with the
   * specified number of items to display at a time, and specified scrolling
   * interval.
   * 
   * @param menu the menu
   * @param scrollCount the number of items to display at a time
   * @param interval the scroll interval, in milliseconds
   * @throws IllegalArgumentException if scrollCount or interval is 0 or negative
   */
  public JMenuScroller(JMenu menu, int scrollCount, int interval) {
    this(menu, scrollCount, interval, 0, 0);
  }

  /**
   * Constructs a <code>JMenuScroller</code> that scrolls a popup menu with the
   * specified number of items to display at a time, and specified scrolling
   * interval.
   * 
   * @param menu the popup menu
   * @param scrollCount the number of items to display at a time
   * @param interval the scroll interval, in milliseconds
   * @throws IllegalArgumentException if scrollCount or interval is 0 or negative
   */
  public JMenuScroller(JPopupMenu menu, int scrollCount, int interval) {
    this(menu, scrollCount, interval, 0, 0);
  }

  /**
   * Constructs a <code>JMenuScroller</code> that scrolls a menu with the
   * specified number of items to display in the scrolling region, the
   * specified scrolling interval, and the specified numbers of items fixed at
   * the top and bottom of the menu.
   * 
   * @param menu the menu
   * @param scrollCount the number of items to display in the scrolling portion
   * @param interval the scroll interval, in milliseconds
   * @param topFixedCount the number of items to fix at the top.  May be 0
   * @param bottomFixedCount the number of items to fix at the bottom.  May be 0
   * @throws IllegalArgumentException if scrollCount or interval is 0 or
   * negative or if topFixedCount or bottomFixedCount is negative
   */
  public JMenuScroller(JMenu menu, int scrollCount, int interval,
          int topFixedCount, int bottomFixedCount) {
    this(menu.getPopupMenu(), scrollCount, interval, topFixedCount, bottomFixedCount);
  }

  /**
   * Constructs a <code>JMenuScroller</code> that scrolls a popup menu with the
   * specified number of items to display in the scrolling region, the
   * specified scrolling interval, and the specified numbers of items fixed at
   * the top and bottom of the popup menu.
   * 
   * @param menu the popup menu
   * @param scrollCount the number of items to display in the scrolling portion
   * @param interval the scroll interval, in milliseconds
   * @param topFixedCount the number of items to fix at the top.  May be 0
   * @param bottomFixedCount the number of items to fix at the bottom.  May be 0
   * @throws IllegalArgumentException if scrollCount or interval is 0 or
   * negative or if topFixedCount or bottomFixedCount is negative
   */
  public JMenuScroller(JPopupMenu menu, int scrollCount, int interval,
          int topFixedCount, int bottomFixedCount) {
    if (scrollCount <= 0 || interval <= 0) {
      throw new IllegalArgumentException("scrollCount and interval must be greater than 0");
    }
    if (topFixedCount < 0 || bottomFixedCount < 0) {
      throw new IllegalArgumentException("topFixedCount and bottomFixedCount cannot be negative");
    }

    upItem = new MenuScrollItem(UP, -1);
    downItem = new MenuScrollItem(DOWN, +1);
    setScrollCount(scrollCount);
    setInterval(interval);
    setTopFixedCount(topFixedCount);
    setBottomFixedCount(bottomFixedCount);

    this.menu = menu;
    menu.addPopupMenuListener(menuListener);
  }

  /**
   * Returns the scroll interval in milliseconds
   * 
   * @return the scroll interval in milliseconds
   */
  public int getInterval() {
    return interval;
  }

  /**
   * Sets the scroll interval in milliseconds
   * 
   * @param interval the scroll interval in milliseconds
   * @throws IllegalArgumentException if interval is 0 or negative
   */
  public void setInterval(int interval) {
    if (interval <= 0) {
      throw new IllegalArgumentException("interval must be greater than 0");
    }
    upItem.setInterval(interval);
    downItem.setInterval(interval);
    this.interval = interval;
  }

  /**
   * Returns the number of items in the scrolling portion of the menu.
   *
   * @return the number of items to display at a time
   */
  public int getscrollCount() {
    return scrollCount;
  }

  /**
   * Sets the number of items in the scrolling portion of the menu.
   * 
   * @param scrollCount the number of items to display at a time
   * @throws IllegalArgumentException if scrollCount is 0 or negative
   */
  public void setScrollCount(int scrollCount) {
    if (scrollCount <= 0) {
      throw new IllegalArgumentException("scrollCount must be greater than 0");
    }
    this.scrollCount = scrollCount;
    // XXX the following line closes all menus then this menu is made.
    // That doesn't seem right.
    // MenuSelectionManager.defaultManager().clearSelectedPath();
  }

  /**
   * Returns the number of items fixed at the top of the menu or popup menu.
   * 
   * @return the number of items
   */
  public int getTopFixedCount() {
    return topFixedCount;
  }

  /**
   * Sets the number of items to fix at the top of the menu or popup menu.
   * 
   * @param topFixedCount the number of items
   */
  public void setTopFixedCount(int topFixedCount) {
    if (firstIndex <= topFixedCount) {
      firstIndex = topFixedCount;
    } else {
      firstIndex += (topFixedCount - this.topFixedCount);
    }
    this.topFixedCount = topFixedCount;
  }

  /**
   * Returns the number of items fixed at the bottom of the menu or popup menu.
   * 
   * @return the number of items
   */
  public int getBottomFixedCount() {
    return bottomFixedCount;
  }

  /**
   * Sets the number of items to fix at the bottom of the menu or popup menu.
   * 
   * @param bottomFixedCount the number of items
   */
  public void setBottomFixedCount(int bottomFixedCount) {
    this.bottomFixedCount = bottomFixedCount;
  }

  /**
   * Scrolls the specified item into view each time the menu is opened.  Call this method with
   * <code>null</code> to restore the default behavior, which is to show the menu as it last
   * appeared.
   *
   * @param item the item to keep visible
   * @see #keepVisible(int)
   */
  public void keepVisible(JMenuItem item) {
    if (item == null) {
      keepVisibleIndex = -1;
    } else {
      int index = menu.getComponentIndex(item);
      keepVisibleIndex = index;
    }
  }

  /**
   * Scrolls the item at the specified index into view each time the menu is opened.  Call this
   * method with <code>-1</code> to restore the default behavior, which is to show the menu as
   * it last appeared.
   *
   * @param index the index of the item to keep visible
   * @see #keepVisible(javax.swing.JMenuItem)
   */
  public void keepVisible(int index) {
    keepVisibleIndex = index;
  }

  /**
   * Removes this JMenuScroller from the associated menu and restores the
   * default behavior of the menu.
   */
  public void dispose() {
    if (menu != null) {
      menu.removePopupMenuListener(menuListener);
      menu = null;
    }
  }

  /**
   * Ensures that the <code>dispose</code> method of this JMenuScroller is
   * called when there are no more refrences to it.
   * 
   * @exception  Throwable if an error occurs.
   * @see JMenuScroller#dispose()
   */
  @Override
  public void finalize() throws Throwable {
    dispose();
  }

  private void refreshMenu() {
    if (menuItems != null && menuItems.length > 0) {
      firstIndex = Math.max(topFixedCount, firstIndex);
      firstIndex = Math.min(menuItems.length - bottomFixedCount - scrollCount, firstIndex);

      upItem.setEnabled(firstIndex > topFixedCount);
      downItem.setEnabled(firstIndex + scrollCount < menuItems.length - bottomFixedCount);

      menu.removeAll();
      for (int i = 0; i < topFixedCount; i++) {
        menu.add(menuItems[i]);
      }
      if (topFixedCount > 0) {
        menu.addSeparator();
      }

      menu.add(upItem);
      for (int i = firstIndex; i < scrollCount + firstIndex; i++) {
        menu.add(menuItems[i]);
      }
      menu.add(downItem);

      if (bottomFixedCount > 0) {
        menu.addSeparator();
      }
      for (int i = menuItems.length - bottomFixedCount; i < menuItems.length; i++) {
        menu.add(menuItems[i]);
      }

      JComponent parent = (JComponent) upItem.getParent();
      parent.revalidate();
      parent.repaint();
    }
  }

  private class MenuScrollListener implements PopupMenuListener {

    @Override
    public void popupMenuWillBecomeVisible(PopupMenuEvent e) {
      if (fillMenu != null) {
        clearPopupMenu(menu);
        callF(fillMenu, menu);
      }
      setMenuItems();
    }

    @Override
    public void popupMenuWillBecomeInvisible(PopupMenuEvent e) {
      if (fillMenu != null) clearPopupMenu(menu);
      else restoreMenuItems();
    }

    @Override
    public void popupMenuCanceled(PopupMenuEvent e) {
      if (fillMenu != null) clearPopupMenu(menu);
      else restoreMenuItems();
    }

    private void setMenuItems() {
      menuItems = menu.getComponents();
      if (keepVisibleIndex >= topFixedCount
              && keepVisibleIndex <= menuItems.length - bottomFixedCount
              && (keepVisibleIndex > firstIndex + scrollCount
              || keepVisibleIndex < firstIndex)) {
        firstIndex = Math.min(firstIndex, keepVisibleIndex);
        firstIndex = Math.max(firstIndex, keepVisibleIndex - scrollCount + 1);
      }
      if (menuItems.length > topFixedCount + scrollCount + bottomFixedCount) {
        refreshMenu();
      }
    }

    private void restoreMenuItems() {
      menu.removeAll();
      for (Component component : menuItems) {
        menu.add(component);
      }
    }
  }

  private class MenuScrollTimer extends javax.swing.Timer {

    public MenuScrollTimer(final int increment, int interval) {
      super(interval, new ActionListener() {

        @Override
        public void actionPerformed(ActionEvent e) {
          firstIndex += increment;
          refreshMenu();
        }
      });
    }
  }

  private class MenuScrollItem extends JMenuItem
          implements ChangeListener {

    private MenuScrollTimer timer;

    public MenuScrollItem(MenuIcon icon, int increment) {
      setIcon(icon);
      setDisabledIcon(icon);
      timer = new MenuScrollTimer(increment, interval);
      addChangeListener(this);
    }

    public void setInterval(int interval) {
      timer.setDelay(interval);
    }

    @Override
    public void stateChanged(ChangeEvent e) {
      if (isArmed() && !timer.isRunning()) {
        timer.start();
      }
      if (!isArmed() && timer.isRunning()) {
        timer.stop();
      }
    }
  }

  static MenuIcon UP = new MenuIcon(9, 1, 9);
  static MenuIcon DOWN = new MenuIcon(1, 9, 1);
    
  private static class MenuIcon implements Icon {

    final int[] xPoints = {1, 5, 9};
    final int[] yPoints;

    MenuIcon(int... yPoints) {
      this.yPoints = yPoints;
    }

    @Override
    public void paintIcon(Component c, Graphics g, int x, int y) {
      Dimension size = c.getSize();
      Graphics g2 = g.create(size.width / 2 - 5, size.height / 2 - 5, 10, 10);
      g2.setColor(Color.GRAY);
      g2.drawPolygon(xPoints, yPoints, 3);
      if (c.isEnabled()) {
        g2.setColor(Color.BLACK);
        g2.fillPolygon(xPoints, yPoints, 3);
      }
      g2.dispose();
    }

    @Override
    public int getIconWidth() {
      return 0;
    }

    @Override
    public int getIconHeight() {
      return 10;
    }
  }
}
static class PtInComponent<A extends Component> implements IFieldsToList{
  A component;
  Pt p;
  PtInComponent() {}
  PtInComponent(A component, Pt p) {
  this.p = p;
  this.component = component;}
  public String toString() { return shortClassName_dropNumberPrefix(this) + "(" + component + ", " + p + ")"; }

public boolean equals(Object o) {
if (!(o instanceof PtInComponent)) return false;
    PtInComponent __1 =  (PtInComponent) o;
    return eq(component, __1.component) && eq(p, __1.p);
}

  public int hashCode() {
    int h = -1774729068;
    h = boostHashCombine(h, _hashCode(component));
    h = boostHashCombine(h, _hashCode(p));
    return h;
  }
  public Object[] _fieldsToList() { return new Object[] {component, p}; }

  PtInComponent(Pt p, A component) {
  this.component = component;
  this.p = p;}
}
static class TableSearcher {
  JTable table;
  JTextField tfInput;
  JComponent searchPanel, panel;
  F2<String, Map, Boolean> rowTester;
  List<Integer> rowIndices;
  SingleComponentPanel scpRightOfSearchPanel = scp();
  List lastFiltered, lastOriginal;

  String input() { return gtt(tfInput); }
  
  void clearSearchField() { setText(tfInput, ""); }
}

static TableSearcher tableWithSearcher2(JTable t, Object... __) {
  TableSearcher s = new TableSearcher();
  boolean precise = true;
  s.table = t;
  s.tfInput = jtextfield();
  s.rowTester = new F2<String, Map, Boolean>() { public Boolean get(String pat, Map row) { try {  return anyValueContainsIgnoreCase(row, pat);  } catch (Exception __e) { throw rethrow(__e); } }
  public String toString() { return "anyValueContainsIgnoreCase(row, pat)"; }};
  
  onUpdate(s.tfInput, new Runnable() {
    public void run() {
      String pat = s.input();
      
      List<Map<String, Object>> data = rawTableData(t);
      if (eq(s.lastFiltered, data))
        data = s.lastOriginal;
        
      //print("Searching " + n(l(data), "entry"));
      List data2 = new ArrayList();
      List<Integer> rowIndices = new ArrayList();
      for (int i = 0; i < l(data); i++) {
        Map<String, Object> map = data.get(i);
        if (isTrue(callF(s.rowTester, pat, map))) {
          data2.add(map);
          rowIndices.add(i);
        }
      }
          
      //print("Found " + n(l(data2), "entry"));
      s.lastFiltered = data2;
      s.lastOriginal = data;
      dataToTable(t, data2);
      if (precise) s.lastFiltered = rawTableData(t);
      s.rowIndices = rowIndices;
    }
  });
  
  s.searchPanel = centerAndEast(withLabel(" Search:", s.tfInput), s.scpRightOfSearchPanel);
  JComponent top = s.searchPanel;
  s.panel = boolOptPar(__, "withMargin") ? northAndCenterWithMargin(top, t) : northAndCenter(top, t);
  return s;
}

abstract static 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>() {
                  private 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>() {
                  private 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(' ');
      }
  }

  protected 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
      private static final long serialVersionUID = -8499721149061103585L;

      @SuppressWarnings("serial")
      private final K key;
      @SuppressWarnings("serial")
      private 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
      private static final long serialVersionUID = 7138329143949025153L;

      @SuppressWarnings("serial")
      private final K key;
      @SuppressWarnings("serial")
      private final 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;
      }
  }
}


interface IF0WithChangeListeners<A> extends IF0<A>, IHasChangeListeners {}


static boolean scaffoldingEnabled(Object o) {
  return metaGet(o, "scaffolding") != null;
}


static void dbWithCase(String caseID) {
  caseID(caseID);
  db();
}


static int awtOnConceptChanges_defaultDelay = 500;

static ThreadLocal<Concepts> awtOnConceptChanges_concepts = new ThreadLocal();

static void awtOnConceptChanges(Component component, Object runnable) {
  awtOnConceptChanges(componentToJComponent(component), runnable, true);
}

static void awtOnConceptChanges(JComponent component, final Object runnable, boolean runOnFirstTime) {
  awtOnConceptChanges(component, awtOnConceptChanges_defaultDelay, 0, runnable, runOnFirstTime);
}

static void awtOnConceptChanges(JComponent component, int delay, final Object runnable) {
  awtOnConceptChanges(component, delay, delay, runnable);
}
  
static void awtOnConceptChanges(JComponent component, int delay, int firstDelay, Object runnable) {
  awtOnConceptChanges(component, delay, firstDelay, runnable, true);
}

static boolean awtOnConceptChanges_debug = false;

static void awtOnConceptChanges(JComponent component, int delay, int firstDelay, final Object runnable, final boolean runOnFirstTime) {
  final Concepts concepts = or(awtOnConceptChanges_concepts.get(), db_mainConcepts());
  installTimer(component, delay, firstDelay, new Runnable() {
    long c = runOnFirstTime ? -1 : concepts.changes;
    boolean skip = false;
    
    public void run() {
      long _c = concepts.changes;
      if (awtOnConceptChanges_debug)
        print("awtOnConceptChanges: " + _c + " / " + c);
      if (skip) skip = false;        
      else if (_c != c) {
        c = _c;
        call(runnable);
        skip = true;
      }
    }
  });
}


static void updateEnclosingTabTitleWithCount(JComponent c, int n) {
  Pair<JTabbedPane, Integer> p = enclosingTab(c);
  if (p == null) return;
  setTabTitle(p.a, p.b, appendBracketedCount(dropTrailingBracketedCount(getTabTitle(p.a, p.b)), n));
}


static <A extends Concept> int conceptCount(Concepts concepts, Class<A> c, Object... params) {
  return countConcepts(concepts, c, params);
}



static <A extends Concept> int conceptCount(Class<A> c, Object... params) {
  return countConcepts(c, params);
}



static int conceptCount() {
  return countConcepts();
}



static int conceptCount(String className) {
  return countConcepts(className);
}



static <A extends Concept> int conceptCount(Concepts concepts, String className) {
  return countConcepts(concepts, className);
}



static int conceptCount(Concepts concepts) {
  return countConcepts(concepts);
}


static int tableColumnCount(JTable table) {
  return tableNumColumns(table);
}


static void setColumnName(final JTable table, final int idx, final String name) {
  if (table != null) { swing(() -> { 
    if (table.getColumnCount() > idx)
      table.getColumnModel().getColumn(idx).setHeaderValue(name);
  }); }
}


static String getColumnName(final JTable table, final int idx) {
  return table == null ? null : swing(new F0<String>() { public String get() { try { 
    return table.getColumnCount() <= idx ? null
      : str(table.getColumnModel().getColumn(idx).getHeaderValue());
   } catch (Exception __e) { throw rethrow(__e); } }
  public String toString() { return "return table.getColumnCount() <= idx ? null\r\n      : str(table.getColumnModel..."; }});
}


static <A extends Container> A addComponent(final A c, final Component component) {
  if (component != null) { swing(() -> { 
    c.add(component);
    revalidate(c);
  }); }
  return c;
}


static JButton tableDependentButton(JTable tbl, String text) { return tableDependentButton(tbl, text, null); }
static JButton tableDependentButton(JTable tbl, String text, Runnable action) {
  return tableDependButton(tbl, jbutton(text, action));
}


static JTable addRowSorter(final JTable table) {
  if (table != null) { swing(() -> { 
    table.setRowSorter(new TableRowSorter(table.getModel()));
  }); }
  return table;
}



// params: column index, Comparator, column index, Comparator, ...
static void rowSorter_setComparatorForAllColumns(JTable table, final Comparator comparator) {
  if (table == null) return;
  setTableModel_fixSorter.put(table, new VF2<JTable, RowSorter>() { public void get(JTable table, RowSorter sorter) { try { 
    if (sorter instanceof TableRowSorter) {
      int n = tableColumnCount(table);
      for (int i = 0; i < n; i++)
        ((TableRowSorter) sorter).setComparator(i, comparator);
    }
   } catch (Exception __e) { throw rethrow(__e); } }
  public String toString() { return "if (sorter cast TableRowSorter) {\r\n      int n = tableColumnCount(table);\r\n  ..."; }});
}



static AlphanumComparator alphaNumComparator_instance;

static Comparator<String> alphaNumComparator() {
  if (alphaNumComparator_instance == null)
    alphaNumComparator_instance = new AlphanumComparator();
  return alphaNumComparator_instance;
}



static void onConceptChangeAndNow(Runnable r) {
  onConceptsChangeAndNow(r);
}

static void onConceptChangeAndNow(Concepts cc, Runnable r) {
  onConceptsChangeAndNow(cc, r);
}


static String dm_originalModuleName() {
  return dm_originalModuleName(assertNotNull(dm_current()));
}

static String dm_originalModuleName(Object module) {
  return (String) callOpt(dm_getStem(module), "originalModuleName");
}


static <A extends Concept> A uniq_sync(final Class<A> c, final Object... params) {
  return uniq(c, params);
}

static <A extends Concept> A uniq_sync(Concepts concepts, Class<A> c, final Object... params) {
  return uniq(concepts, c, params);
}


static <A extends Concept> Pair<A, Boolean> uniq2_sync(Class<A> c, final Object... params) {
  return uniq2(c, params);
}

static <A extends Concept> Pair<A, Boolean> uniq2_sync(Concepts cc, Class<A> c, final Object... params) {
  return uniq2(cc, c, params);
}


// returns number of changes
static int _cset(Concept c, Object... values) {
  return cset(c, values);
}


// assumes you also use serveHttp (for classes MyHTTPD and NanoHTTPD)
  
static MyHTTPD serveHttps_server;
static int serveHttps_port = 8889;

static void serveHttps(int port, SSLServerSocketFactory socketFactory) { try {
  serveHttps_port = port;
  serveHttps_server = new MyHTTPD(port);
  serveHttps_server.makeSecure(socketFactory);
  serveHttps_server.start();
  print("HTTPS server started (socket factory: " + socketFactory + ", listening on port " + port + "!)");
} catch (Exception __e) { throw rethrow(__e); } }

static void serveHttps(int port, File keystore, String pass) { try {
  serveHttps(port, serveHttps_makeSSLSocketFactory(keystore, pass));
} catch (Exception __e) { throw rethrow(__e); } }

// uses default SSLServerSocketFactory - doesn't seem to work
static void serveHttps(int port) { try {
  serveHttps_port = port;
  serveHttps_server = new MyHTTPD(port);
  serveHttps_server.makeSecure((SSLServerSocketFactory) SSLServerSocketFactory.getDefault());
  serveHttps_server.start();
  print("HTTPS server started with default socket factory (listening on port " + port + "!)");
} catch (Exception __e) { throw rethrow(__e); } }

// seems to assume same password is used for keystore as well as certificate.
static SSLServerSocketFactory serveHttps_makeSSLSocketFactory(File keystoreFile, String passphrase) { try {
  KeyStore keystore = KeyStore.getInstance(KeyStore.getDefaultType());
   InputStream keystoreStream = new FileInputStream(keystoreFile); try {
  keystore.load(keystoreStream, passphrase.toCharArray());
  TrustManagerFactory trustManagerFactory = TrustManagerFactory.getInstance(TrustManagerFactory.getDefaultAlgorithm());
  trustManagerFactory.init(keystore);
  KeyManagerFactory keyManagerFactory = KeyManagerFactory.getInstance(KeyManagerFactory.getDefaultAlgorithm());
  keyManagerFactory.init(keystore, passphrase.toCharArray());
  SSLContext ctx = SSLContext.getInstance("TLS");
  ctx.init(keyManagerFactory.getKeyManagers(), trustManagerFactory.getTrustManagers(), null);
  return ctx.getServerSocketFactory();
} finally { _close(keystoreStream); }} catch (Exception __e) { throw rethrow(__e); } }

static void cleanMeUp_serveHttps() {
  if (serveHttps_server != null) {
    serveHttps_server.stop();
    serveHttps_server = null;
  }
}


static String serveHttp_domainName() { 
  NanoHTTPD.IHTTPSession session = NanoHTTPD.currentSession.get();
  if (session == null) return null;
  return session.getHeaders().get("host");
}


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


static GlobalID aGlobalIDObjUnlessLoading() {
  return dynamicObjectIsLoading() ? null : aGlobalIDObj();
}


static JPanel centerAndSouthWithMargins(Swingable c, Swingable s) { return centerAndSouthWithMargins(c, toComponent(s)); }

static JPanel centerAndSouthWithMargins(Swingable c, Component s) { return centerAndSouthWithMargins(toComponent(c), s); }

static JPanel centerAndSouthWithMargins(Component c, Swingable s) { return centerAndSouthWithMargins(c, toComponent(s)); }

static JPanel centerAndSouthWithMargins(Component c, Component s) {
  return applyDefaultMargin(centerAndSouth(c, withTopMargin(s)));
}

static JPanel centerAndSouthWithMargins(int margin, Swingable c, Swingable s) { return centerAndSouthWithMargins(margin, c, toComponent(s)); }

static JPanel centerAndSouthWithMargins(int margin, Swingable c, Component s) { return centerAndSouthWithMargins(margin, toComponent(c), s); }

static JPanel centerAndSouthWithMargins(int margin, Component c, Swingable s) { return centerAndSouthWithMargins(margin, c, toComponent(s)); }

static JPanel centerAndSouthWithMargins(int margin, Component c, Component s) {
  return applyMargin(margin, centerAndSouth(c, withTopMargin(margin, s)));
}


static SingleComponentPanel singleComponentPanel() {
  return singleComponentPanel(null);
}

static 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 JPanel jrightalignedline(Component... components) {
  return jrightAlignedLine(components);
}

static JPanel jrightalignedline(List<Component> components) {
  return jrightAlignedLine(components);
}


static JPanel centerAndEastWithMargin(Swingable c, Swingable e) { return centerAndEastWithMargin(c, toComponent(e)); }

static JPanel centerAndEastWithMargin(Swingable c, Component e) { return centerAndEastWithMargin(toComponent(c), e); }

static JPanel centerAndEastWithMargin(Component c, Swingable e) { return centerAndEastWithMargin(c, toComponent(e)); }

static JPanel centerAndEastWithMargin(Component c, Component e) {
  return centerAndEastWithMarginInbetween(c, e);
}


static JCheckBox dm_fieldCheckBox(String field) {
  return dm_fieldCheckBox(humanizeFormLabel(field), field);
}

static JCheckBox dm_fieldCheckBox(String text, String field) {
  // magic parameter swap :)
  if (isIdentifier(text) && !isIdentifier(field)) { String temp = field; field = text; text = temp; }
  return jLiveValueCheckBox(text, dm_fieldLiveValue(field));
}


static void addComponentsFirst(Container c, Component... l) {
  containerAddFirst(c, l);
}


static void scpSet(SingleComponentPanel scp, Component c) {
  setSCPComponent(scp, c);
}




static 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 <A> Value<A> value(A a) {
  return new Value<A>(a);
}


static <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 Q dm_q() {
  return dm_current_mandatory().q();
}

static void dm_q(Runnable r) {
  dm_inQ(r);
}

static void dm_q(DynModule module, Runnable r) {
  module.q().add(r);
}

static <A> A dm_q(IF0<A> f) {
  return dm_evalInQ(if0ToF0(f));
}


static double fracNonNeg(double d) {
  return frac_nonNeg(d);
}


static double twoPi() {
  return Math.PI*2;
}


static String plusPrefixUnlessMinus(String s) {
  return startsWith(s, "-") ? s : "+" + s;
}


static void addSeparator(JMenu menu) {
  menu.addSeparator();
}

static void addSeparator(JPopupMenu menu) {
  menu.addSeparator();
}


static void truncateContainer(Container c, int n) { swing(() -> { 
  if (c != null)
    while (c.getComponentCount() > n)
      c.remove(c.getComponentCount()-1);
}); }


static <A extends Component> A packWindow(final A c) {
  { swing(() -> { 
    Window w = getWindow(c);
    if (w != null) w.pack();
  }); }
  return c;
}


static <A> VF1<A> toVF1(IVF1<A> f) {
  return ivf1ToVF1(f);
}


static PtInComponent ptInComponentFromEvent(MouseEvent evt) {
  return new PtInComponent(evt.getComponent(), pt(evt.getX(), evt.getY()));
}


static boolean hasParentOfType(Class<?> type, Component c) {
  return parentOfType(c, type) != null;
}


static Set expiringSet(long standardExpiryTime) {
  return Collections.newSetFromMap((Map) syncExpiringMap(standardExpiryTime));
}

static Set expiringSet(double standardExpirySeconds) {
  return Collections.newSetFromMap((Map) syncExpiringMap(standardExpirySeconds));
}


static <A, B> B pairB(Pair<A, B> p) {
  return p == null ? null : p.b;
}




static int simpleSpamClientDetect2_interval = 60000;
static double simpleSpamClientDetect2_perSecondThreshold = 2.0; // per IP + URI
static int simpleSpamClientDetect2_spamMax;
static Set<String> simpleSpamClientDetect2_whiteList = syncSet(myIPs());
static Lock simpleSpamClientDetect2_myLock = lock();

// ip + uri -> time, count
static Map<Pair<String, String>, Pair<Long, Integer>> simpleSpamClientDetect2_ipsAndUris = synchroMap();

// returns pair(count, bad)
static Pair<Integer, Boolean> simpleSpamClientDetect2(String clientIP, String uri) {
  Lock __0 = simpleSpamClientDetect2_myLock; lock(__0); try {
  // TODO: clean up map sometimes
  Pair<String, String> pair = pair(clientIP, uri);
  Pair<Long, Integer> value = simpleSpamClientDetect2_ipsAndUris.get(pair);
  if (value == null || now() > value.a+simpleSpamClientDetect2_interval)
    simpleSpamClientDetect2_ipsAndUris.put(pair, value = pair(now(), 1));
  else
    value.b++;
  simpleSpamClientDetect2_spamMax = iround(simpleSpamClientDetect2_perSecondThreshold*simpleSpamClientDetect2_interval/1000);
  return pair(value.b, !contains(simpleSpamClientDetect2_whiteList, clientIP) && value.b >= simpleSpamClientDetect2_spamMax);
} finally { unlock(__0); } }

// returns new count
static int simpleSpamClientDetect2_markNoSpam(String clientIP, String uri) {
  Lock __1 = simpleSpamClientDetect2_myLock; lock(__1); try {
  Pair<String, String> pair = pair(clientIP, uri);
  Pair<Long, Integer> value = simpleSpamClientDetect2_ipsAndUris.get(pair);
  if (value != null && value.b > 0) return --value.b;
  return -1;
} finally { unlock(__1); } }




static String pcall_myFirewallIP() { try {
  return myFirewallIP();
} catch (Throwable __e) { return null; } }


static <A, B, C> T3<A, B, C> t3(A a, B b, C c) {
  return new T3(a, b, c);
}




static String dateWithTimeGMT(long time) {
  SimpleDateFormat format = simpleDateFormat_GMT("yyyy/MM/dd");
  return format.format(time) + " " + formatGMT_24(time);
}

static String dateWithTimeGMT() {
  return dateWithTimeGMT(now());
}


static void setComponent(SingleComponentPanel scp, Component c) {
  setSCPComponent(scp, c);
}

static void setComponent(SingleComponentPanel scp, IF0<Component> c) {
  if (scp != null)
    setComponent(scp, callF(c));
}


static <A> boolean removeAll(Collection<A> a, Collection<A> b) {
  return a != null && b != null && a.removeAll(b);
}

static <A, B> void removeAll(Map<A, B> a, Collection<A> b) {
  if (a != null && b != null)
    for (A x : b)
      a.remove(x);
}

static <A, B extends A> boolean removeAll(Collection<A> c, B... b) {
  return c != null && b != null && c.removeAll(Arrays.asList(b));
}

static <A, B> void removeAll(Map<A, B> a, A... b) {
  if (a != null && b != null)
    for (A x : b)
      a.remove(x);
}


static Container _getParent(Component c) {
  return getParent(c);
}


static WebSocketFactory webSocketFactory(final Object factory) {
  if (factory instanceof WebSocketFactory) return ((WebSocketFactory) factory);
  if (factory == null) return null;
  return new WebSocketFactory() {
    public WebSocket openWebSocket(NanoHTTPD.IHTTPSession handshake) {
      return (WebSocket) callF(factory, handshake);
    }
  };
}


static void nanohttpd_socketTimeoutFix() {
  NanoHTTPD.SOCKET_READ_TIMEOUT = 24*3600*1000;
}


// o can be a class, then we search for a static method called "html".
static Object callHtmlMethod2(Object o, String uri) {
  return callHtmlMethod2(o, uri, null);
}

static Object callHtmlMethod2(Object o, String uri, Map<String, String> params) {
  Object s = callOpt(o, "html", uri, params);
  if (s == null)
    s = callOpt(o, "html", uri);
  if (s == null)
    s = callOpt(o, "html");
  return s;
}



static <A> A nu(Class<A> c, Object... values) {
  A a = nuObject(c);
  setAll(a, values);
  return a;
}


static String formatDateAndTime(long timestamp) {
  return formatDate(timestamp);
}

static String formatDateAndTime() {
  return formatDate();
}





static NanoHTTPD.Response serveHTML(Object text) {
  return NanoHTTPD.newFixedLengthResponse(str(text));
}



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

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


static <A extends Component> A maximizeFrame(A c) {
  JFrame f = swing(new F0<JFrame>() { public JFrame get() { try { 
    JFrame f = getFrame(c);
    if (f != null)
      f.setExtendedState(JFrame.MAXIMIZED_BOTH);
    return f;
   } catch (Exception __e) { throw rethrow(__e); } }
  public String toString() { return "JFrame f = getFrame(c);\r\n    if (f != null)\r\n      f.setExtendedState(JFrame...."; }});
  
  // wait until frame is actually maximized so
  // we can add components based on correct size
  if (f != null && !isAWTThread()) {
    Dimension d = maximumWindowBounds().getSize();
    long start = sysNow();
    while (licensed()) { try {
      if (f.getWidth() >= d.getWidth()-100 && f.getHeight() >= d.getHeight()-100) break;
      if (sysNow() >= start+100) { warn("maximizeFrame timeout"); break; }
    } catch (Throwable __e) { pcallFail(__e); } sleep(1); }
  }
  return c;
}



static volatile boolean framesBot_has = false;

static Android3 framesBot() {
  if (framesBot_has) return null;
  framesBot_has = true;
  Android3 android = new Android3();
  android.greeting = programIDPlusHome() + " Frames.";
  android.console = false;
  android.responder = new Responder() {
    public String answer(String s, List<String> history) {
      if (match("activate frames", s)) {
        swingLater(new Runnable() {  public void run() { try {  // prevent blocking when called from same program's AWT thread
          activateMyFrames();
        
} catch (Exception __e) { throw rethrow(__e); } }  public String toString() { return "// prevent blocking when called from same program's AWT thread\r\n          act..."; }});
        return "OK, activating " + programName();
      }
      return null;
    }
  };
  return makeBot(android);
}


static void indexConceptClass(Class<? extends Concept> c) { indexConceptClass(db_mainConcepts(), c); }
static void indexConceptClass(Concepts cc, Class<? extends Concept> c) {
  ensureConceptClassIsIndexed(cc, c);
}


// optional parameters
static ThreadLocal<List<String>> showConceptsTable_dropFields = new ThreadLocal();
static ThreadLocal showConceptsTable_postProcess = new ThreadLocal(); // func(L) -> L
static ThreadLocal showConceptsTable_afterUpdate = new ThreadLocal(); // voidfunc(JTable)
static ThreadLocal<Concepts> showConceptsTable_concepts = new ThreadLocal();
static ThreadLocal<Boolean> showConceptsTable_latestFirst = new ThreadLocal();
static ThreadLocal<Object> showConceptsTable_sorter = new ThreadLocal(); // func(Cl<Concept>) -> Cl<Concept>

static int makeConceptsTable_idWidth = 50;

static JTable showConceptsTable(Class<? extends Concept> c) {
  JTable table = makeConceptsTable(c);
  showFrame(plural(shortClassName(c)), table);
  return table;
}

static JTable makeConceptsTable(Class<? extends Concept> c) {
  List<String> dropFields = getAndClearThreadLocal(showConceptsTable_dropFields);
  Object pp = getAndClearThreadLocal(showConceptsTable_postProcess);
  Object afterUpdate = optParam(showConceptsTable_afterUpdate);
  Concepts concepts = optParam(showConceptsTable_concepts, db_mainConcepts());
  boolean latestFirst = boolParam(showConceptsTable_latestFirst);
  Object sorter = optParam(showConceptsTable_sorter);
  boolean useStruct = boolParam(dataToTable_useStruct);

  final List<String> fields = listMinusList(concatLists(ll("id"), conceptFieldsInOrder(c)), dropFields);
  final JTable table = sexyTable();
  tablePopupMenu(table, new VF2<JPopupMenu, Integer>() { public void get(JPopupMenu menu, final Integer row) { try { 
    addMenuItem(menu, "Delete", new Runnable() {  public void run() { try { 
      final long id = toLong(getTableCell(table, row, 0));
      deleteConcept_sync(concepts, id);
    
} catch (Exception __e) { throw rethrow(__e); } }  public String toString() { return "final long id = toLong(getTableCell(table, row, 0));\r\n      deleteConcept_syn..."; }});
   } catch (Exception __e) { throw rethrow(__e); } }
  public String toString() { return "addMenuItem(menu, \"Delete\", r {\r\n      final long id = toLong(getTableCell(ta..."; }});
   AutoCloseable __1 = tempSetTL(awtOnConceptChanges_concepts, concepts); try {
  awtOnConceptChanges(table, new Runnable() {  public void run() { try { 
    //print("Updating concept table");
    List<List> data = new ArrayList();
    Collection<? extends Concept> l = list(concepts, c);
    if (sorter != null) l = (Collection) callF(sorter, l);
    for (Concept cc : l)
      data.add(map(new F1<String, Object>() { public Object get(String field) { try { 
        Object value = cget(cc, field);
        return useStruct ? renderForTable(value)
                      : renderForTable_noStruct(value);
       } catch (Exception __e) { throw rethrow(__e); } }
  public String toString() { return "O value = cget(cc, field);\r\n        ret useStruct ? renderForTable(value)\r\n  ..."; }}, fields));
    if (latestFirst) reverseInPlace(data);
    data = (List) postProcess(pp, data);
    fillTableWithData(table, data, map(__106 -> humanizeFormLabel(__106), fields));
    if (table.getColumnCount() > 0)
      table.getColumnModel().getColumn(0).setMaxWidth(makeConceptsTable_idWidth);
    pcallF(afterUpdate, table);
  
} catch (Exception __e) { throw rethrow(__e); } }  public String toString() { return "//print(\"Updating concept table\");\r\n    new List<List> data;\r\n    Collection<..."; }}, true);
  return table;
} finally { _close(__1); }}

// renderer takes a concept and makes a map for display
static <A extends Concept> JTable makeConceptsTable(final Class<A> cClass, final Object renderer) {
  if (renderer == null) return makeConceptsTable(cClass);
  final Object pp = optParam(showConceptsTable_postProcess);
  final Object afterUpdate = optParam(showConceptsTable_afterUpdate);
  final Concepts concepts = optParam(showConceptsTable_concepts, db_mainConcepts());
  final boolean latestFirst = boolParam(showConceptsTable_latestFirst);
  Object sorter = optParam(showConceptsTable_sorter);
  boolean useStruct = boolParam(dataToTable_useStruct);
  
  final JTable table = sexyTable();
   AutoCloseable __2 = tempSetTL(awtOnConceptChanges_concepts, concepts); try {
  awtOnConceptChanges(table, 1000, new Runnable() {  public void run() { try { 
    List<Map> data = new ArrayList();
    Collection<A> l = list(concepts, cClass);
    if (sorter != null) l = (Collection) callF(sorter, l);
    for (A c : l)
      addIfNotNull(data, (Map) pcallF(renderer, c));
    if (latestFirst) reverseInPlace(data);
    data = (List) postProcess(pp, data);
    
     AutoCloseable __3 = tempSetTL(dataToTable_useStruct, useStruct); try {
    dataToTable_uneditable(data, table);
    pcallF(afterUpdate, table);
  
} finally { _close(__3); }} catch (Exception __e) { throw rethrow(__e); } }  public String toString() { return "new List<Map> data;\r\n    Collection<A> l = list(concepts, cClass);\r\n    if (s..."; }});
  return table;
} finally { _close(__2); }}

static <A extends Concept> JTable showConceptsTable(final Class<A> c, final Object f) {
  JTable table = makeConceptsTable(c, f);
  showFrame(plural(shortClassName(c)), table);
  return table;
}

static <A extends Concept> JTable showConceptsTable(String title, Class<A> cClass, Object f) {
  return setFrameTitle(title, showConceptsTable(cClass, f));
}


static JPanel jRightAlignedLine(Component... components) {
  return jrightAlignedLine(components);
}

static JPanel jRightAlignedLine(List<? extends Component> components) {
  return jrightAlignedLine(components);
}


static JButton tableDependButton(JTable tbl, JButton b) {
  tableDependButtons(tbl, ll(b));
  return b;
}

static JButton tableDependButton(JTable tbl, String text, Object action) {
  return tableDependButton(tbl, jbutton(text, action));
}


static <A extends Concept> A selectedConcept(JTable table, Class<A> cc) {
  return (A) getConcept(toLong(selectedTableCell(table, 0)));
}


static Object withDBLock(Object r) {
  Lock __0 = db_mainConcepts().lock; lock(__0); try {
  return callF(r);
} finally { unlock(__0); } }

static <A> A withDBLock(F0<A> r) {
  return (A) withDBLock((Object) r);
}

static Object withDBLock(Concepts concepts, Object r) {
  Lock __1 = concepts.lock; lock(__1); try {
  return callF(r);
} finally { unlock(__1); } }

static <A> A withDBLock(Concepts concepts, F0<A> r) {
  return (A) withDBLock(concepts, (Object) r);
}

static <A> A withDBLock(Concept concept, IF0<A> r) {
  return (A) withDBLock(concept._concepts, r);
}


static JPanel centerAndSouthWithMargin(Swingable c, Swingable s) { return centerAndSouthWithMargin(c, toComponent(s)); }

static JPanel centerAndSouthWithMargin(Swingable c, Component s) { return centerAndSouthWithMargin(toComponent(c), s); }

static JPanel centerAndSouthWithMargin(Component c, Swingable s) { return centerAndSouthWithMargin(c, toComponent(s)); }

static JPanel centerAndSouthWithMargin(Component c, Component s) {
  return centerAndSouth(c, withTopMargin(s));
}

static JPanel centerAndSouthWithMargin(int margin, Swingable c, Swingable s) { return centerAndSouthWithMargin(margin, c, toComponent(s)); }

static JPanel centerAndSouthWithMargin(int margin, Swingable c, Component s) { return centerAndSouthWithMargin(margin, toComponent(c), s); }

static JPanel centerAndSouthWithMargin(int margin, Component c, Swingable s) { return centerAndSouthWithMargin(margin, c, toComponent(s)); }

static JPanel centerAndSouthWithMargin(int margin, Component c, Component s) {
  return centerAndSouth(c, withTopMargin(margin, s));
}


static int withBottomMargin_defaultWidth = 6;

static JPanel withBottomMargin(Swingable c) { return withBottomMargin(toComponent(c)); }

static JPanel withBottomMargin(Component c) { return withBottomMargin(withBottomMargin_defaultWidth, c); }
static JPanel withBottomMargin(int w, Swingable c) { return withBottomMargin(w, toComponent(c)); }

static JPanel withBottomMargin(int w, 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..."; }});
}


// action: voidfunc(int row)
static void tablePopupMenuItem(JTable table, String name, Object action) {
  tablePopupMenu(table, new VF2<JPopupMenu, Integer>() { public void get(JPopupMenu menu, final Integer row) { try { 
    addMenuItem(menu, name, new Runnable() {  public void run() { try {  pcallF(action, row) ;
} catch (Exception __e) { throw rethrow(__e); } }  public String toString() { return "pcallF(action, row)"; }});
   } catch (Exception __e) { throw rethrow(__e); } }
  public String toString() { return "addMenuItem(menu, name, r { pcallF(action, row) });"; }});
}

static void tablePopupMenuItem(JTable table, String name, IVF1<Integer> action) {
  tablePopupMenuItem(table, name, (Object) action);
}


// runnable can be a func(O o) {} receving the selected item
static JList onDoubleClick(final JList list, final Object runnable) {
  { swing(() -> { 
    list.addMouseListener(new MouseAdapter() {
      public void mouseClicked(MouseEvent evt) {
        if (evt.getClickCount() == 2) {
          int idx = list.locationToIndex(evt.getPoint());
          Object item = list.getModel().getElementAt(idx);
          list.setSelectedIndex(idx);
          callF(runnable, item);
        }
      }
    });
  }); }
  return list;
}

// runnable can be a func(O o) {} receving the selected row index
static JTable onDoubleClick(final JTable table, final Object runnable) {
  { swing(() -> { 
    table.addMouseListener(new MouseAdapter() {
      public void mouseClicked(MouseEvent evt) {
        if (evt.getClickCount() == 2) {
          int idx = table.rowAtPoint(evt.getPoint());
          table.setRowSelectionInterval(idx, idx);
          callF(runnable, idx);
        }
      }
    });
  }); }
  return table;
}

// other components get the pointer position
// only reacts on left button
static void onDoubleClick(final JComponent c, final Object runnable) {
  { swing(() -> { 
    c.addMouseListener(new MouseAdapter() {
      public void mouseClicked(MouseEvent evt) {
        if (evt.getButton() == 1 && evt.getClickCount() == 2)
          callF(runnable, evt.getPoint());
      }
    });
  }); }
}


static LinkedHashMap litorderedmap(Object... x) {
  LinkedHashMap map = new LinkedHashMap();
  litmap_impl(map, x);
  return map;
}


static <A extends Concept> A ccopyFieldsExcept(Concept x, A y, Set<String> dontCopyFields) {
  if (x == null || y == null) return y;
  return ccopyFields2(x, y, setMinusSet(conceptFields(x), dontCopyFields));
}


static AutoCloseable tempSetMCOpt(final String field, Object value) {
  final Object oldValue = getMCOpt(field);
  setMCOpt(field, value);
  return new AutoCloseable() { public String toString() { return "setMCOpt(field, oldValue);"; } public void close() throws Exception { setMCOpt(field, oldValue); }};
}


static JPanel showFormTitled2(String title, Object... parts) {
  return showFormTitled_customLayout(formLayouter1(), title, parts);
}


// one array plus more elements
static Object[] arrayPlus(Object[] a1, Object... a2) {
  return concatArrays(a1, a2);
}


static int selectedRow(JTable t) {
  return selectedTableRow(t);
}


static Object getTableCell(JTable tbl, int row, int col) {
  if (row >= 0 && row < tbl.getModel().getRowCount())
    return tbl.getModel().getValueAt(row, col);
  return null;
}


static int tableRowCount(JTable table) {
  return tableRows(table);
}


static Class getFieldType(Object o, String field) {
  return fieldType(o, field);
}


static JCheckBox jCenteredCheckBox() {
  return centerCheckBox(new JCheckBox());
}

static JCheckBox jCenteredCheckBox(boolean checked) {
  return centerCheckBox(new JCheckBox("", checked));
}

static JCheckBox jCenteredCheckBox(String text, boolean checked) {
  return centerCheckBox(new JCheckBox(text, checked));
}

static JCheckBox jCenteredCheckBox(String text) {
  return centerCheckBox(new JCheckBox(text));
}
  
static JCheckBox jCenteredCheckBox(String text, boolean checked, final Object onChange) {
  return centerCheckBox(jCheckBox(text, checked, onChange));
}
  
// onChange can be a Runnable or a voidfunc(bool)
static JCheckBox jCenteredCheckBox(boolean checked, final Object onChange) {
  return centerCheckBox(jCheckBox(checked, onChange));
}


static JTextArea typeWriterTextArea() {
  return newTypeWriterTextArea();
}

static JTextArea typeWriterTextArea(String text) {
  return newTypeWriterTextArea(text);
}


static boolean isSubtype(Class a, Class b) {
  return isSubclass(a, b);
}


static JComboBox jcomboboxFromConcepts_str(Class<? extends Concept> cc) {
  return jcomboboxFromConcepts_str(db_mainConcepts(), cc);
}

static JComboBox jcomboboxFromConcepts_str(Concepts concepts, Class<? extends Concept> cc) { return jcomboboxFromConcepts_str(concepts, cc, null); }
static JComboBox jcomboboxFromConcepts_str(Concepts concepts, Class<? extends Concept> cc, Concept selected) {
  List<String> items = ll("");
  String selectedItem = null;
  for (Concept c : list(concepts, cc)) {
    String item = c.id + " - " + c;
    if (c == selected) selectedItem = item;
    items.add(item);
  }
  return jcombobox(items, selectedItem);
}


static JPasswordField jpassword() {
  return jpassword("");
}

static JPasswordField jpassword(final String pw) {
  return swing(new F0<JPasswordField>() { public JPasswordField get() { try {  return new JPasswordField(pw);  } catch (Exception __e) { throw rethrow(__e); } }
  public String toString() { return "return new JPasswordField(pw);"; }});
}


static AutoComboBox autoComboBox() {
  return autoComboBox(new ArrayList());
}

static AutoComboBox autoComboBox(final Collection<String> items) {
  return swing(new F0<AutoComboBox>() { public AutoComboBox get() { try { 
    AutoComboBox cb = new AutoComboBox();
    cb.setKeyWord(items);
    return cb;
   } catch (Exception __e) { throw rethrow(__e); } }
  public String toString() { return "new AutoComboBox cb;\r\n    cb.setKeyWord(items);\r\n    ret cb;"; }});
}

static AutoComboBox autoComboBox(String value, Collection<String> items) {
  return setText(autoComboBox(items), value);
}


static List collect(Iterable c, String field) {
  return collectField(c, field);
}

static List collect(String field, Iterable c) {
  return collectField(c, field);
}

/*ifclass Concept
static L collect(Class c, S field) {
  ret collect(list(c), field);
}
endif
TODO: make translator ignore stuff in ifclass until resolved
*/


static JComponent unwrap(JComponent c) {
  return c instanceof JScrollPane ? unwrapScrollPane((JScrollPane) c) : c;
}


static Object convertToField(Object o, Class c, String field) {
  Field f = setOpt_findField(c, field);
  if (f == null) return o;
  Class t = f.getType();
  if (t == Long.class || t == long.class)
    return toLong(o);
  else if (t == Integer.class || t == int.class)
    return toInt(o);
  else if (t == Float.class || t == float.class)
    return toFloat(o);
  else if (t == Double.class || t == double.class)
    return toDouble(o);
  else if (t == String.class)
    return o instanceof String ? ((String) o) : str(o);
  else if (t == File.class) {
    if (o instanceof String) return new File((String) o).getAbsoluteFile();
  } else if (t == Pt.class) {
    if (o instanceof String) return parsePt((String) o);
  } else if (t == Rect.class) {
    if (o instanceof String) return parseRect((String) o);
  }
  
  
    else if (t == GlobalID.class && o instanceof String)
      return new GlobalID((String) o);
  
  return o;
}


static String trimIf(boolean b, String s) {
  return b ? trim(s) : s;
}


static long parseFirstLong(String s) {
  return parseLong(jextract("<int>", s));
}


static void cUpdatePNGFile(Concept c, String field, BufferedImage image, boolean deleteOldFile) {
  PNGFile png =  (PNGFile) (cget(c, field));
  if (image == null && png  != null)
    cset(c, field, null);
  else if (image != null &&
    (png == null || !imagesIdentical(png.getImage(), image))) {
    if (png != null && deleteOldFile) png.delete();
    cset(c, field, new PNGFile(image));
  }
}



static Set<String> fields(Object c) {
  return listFields(c);
}


static <A> List<A> listWithoutSet(Collection<A> l, Collection<A> stuff) {
  return listMinusSet(l, stuff);
}


static List<String> conceptFieldsInOrder(Concept c) {
  return conceptFieldsInOrder(c.getClass());
}

static List<String> conceptFieldsInOrder(Class<? extends Concept> c) {
  String order = toStringOpt(getOpt(c, "_fieldOrder"));
  Set<String> set = asTreeSet(conceptFields(c));
  if (order == null) return asList(set);
  List<String> fields = listIntersectSet(splitAtSpace(order), set);
  setAddAll(fields, set);
  return fields;
}


static <A> Set<A> joinSets(Collection<A>... l) {
  Set<A> set = similarEmptySet(first(l));
  for (Collection<A> o : l)
    if (o != null)
      set.addAll(o);
  return set;
}


static <A> Set<A> setPlus(Collection<A> l, A... more) {
  Set<A> set = similarEmptySet(l);
  addAll(set, l);
  for (A a : more) set.add(a);
  return set;
}


static String structureOrText_crud(Object o) {
  if (o == null) return "";
  if (o instanceof Long) return str(o); // avoid the "L"
  if (o instanceof File) return ((File) o).getAbsolutePath();
  return str(o);
}


static boolean hasLock(Lock lock) {
  return ((ReentrantLock) lock).isHeldByCurrentThread();
}


static void clearPopupMenu(final JPopupMenu menu) {
  if (menu != null) { swing(() -> {  menu.removeAll(); }); }
}


static SingleComponentPanel scp() {
  return singleComponentPanel();
}



static SingleComponentPanel scp(Component c) {
  return singleComponentPanel(c);
}


static boolean anyValueContainsIgnoreCase(Map map, String pat) {
  for (Object val : values(map))
    if (val instanceof String && containsIgnoreCase((String) val, pat))
      return true;
  return false;
}


static List<Map<String, Object>> rawTableData(JTable t) {
  int n = tableRows(t);
  List l = new ArrayList();
  for (int i = 0; i < n; i++)
    l.add(rawTableLineAsMap(t, i));
  return l;
}


static JTable dataToTable(Object data) {
  return dataToTable(showTable(), data);
}

static JTable dataToTable(Object data, String title) {
  return dataToTable(showTable(title), data);
}

static JTable dataToTable(JTable table, Object data) {
  return dataToTable(table, data, false);
}

// "now" is ignored now
static JTable dataToTable(JTable table, Object data, boolean now) {
  List<List> rows = new ArrayList();
  List<String> cols = new ContentsIndexedList();

  if (data instanceof List) {
    for (Object x : (List) data) { try {
      rows.add(dataToTable_makeRow(x, cols));
    } catch (Throwable __e) { pcallFail(__e); }}
  } else if (data instanceof Map) {
    Map map =  (Map) data;
    for (Object key : map.keySet()) {
      Object value = map.get(key);
      rows.add(litlist(structureOrTextForUser(key), structureOrTextForUser(value)));
    }
  } else if (data != null)
    print("Unknown data type: " + data);

  fillTableWithData(table, rows, cols);
  return table;
}



static 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 JComponent withLabel(String label, JComponent component) {
  return westAndCenter(jlabel(label + " "), component);
}

static JComponent withLabel(JComponent label, JComponent component) {
  return westAndCenterWithMargin(label, component);
}



static boolean boolOptPar(ThreadLocal<Boolean> tl) {
  return boolOptParam(tl);
}



// defaults to false
static boolean boolOptPar(Object[] __, String name) {
  return boolOptParam(__, name);
}

static boolean boolOptPar(String name, Object[] __) {
  return boolOptParam(__, name);
}


static JPanel northAndCenterWithMargin(int margin, Swingable n, Swingable c) { return northAndCenterWithMargin(margin, n, toComponent(c)); }

static JPanel northAndCenterWithMargin(int margin, Swingable n, Component c) { return northAndCenterWithMargin(margin, toComponent(n), c); }

static JPanel northAndCenterWithMargin(int margin, Component n, Swingable c) { return northAndCenterWithMargin(margin, n, toComponent(c)); }

static JPanel northAndCenterWithMargin(int margin, Component n, Component c) {
  return northAndCenter(withBottomMargin(margin, n), c);
}

static JPanel northAndCenterWithMargin(Swingable n, Swingable c) { return northAndCenterWithMargin(n, toComponent(c)); }

static JPanel northAndCenterWithMargin(Swingable n, Component c) { return northAndCenterWithMargin(toComponent(n), c); }

static JPanel northAndCenterWithMargin(Component n, Swingable c) { return northAndCenterWithMargin(n, toComponent(c)); }

static JPanel northAndCenterWithMargin(Component n, Component c) {
  return northAndCenter(withBottomMargin(n), c);
}


static JPanel northAndCenter(Component n, Component c) {
  return centerAndNorth(c, n);
}




static Map<JTable, VF1<JTable>> setTableModel_after = weakHashMap();
static Map<JTable, VF2<JTable, RowSorter>> setTableModel_fixSorter = weakHashMap();

static void setTableModel(final JTable table, final TableModel model) {
  { swing(() -> { 
    Map<String, Integer> widths = tableColumnWidthsByName(table);
    int[] i = table.getSelectedRows();
    TableRowSorter sorter = model.getColumnCount() == tableColumnCount(table) ? (TableRowSorter) table.getRowSorter() : null;
    List<? extends RowSorter.SortKey> sortKeys = sorter == null ? null : sorter.getSortKeys();
    table.setModel(model);
    int n = model.getRowCount();
    ListSelectionModel sel = table.getSelectionModel();
    for (int j = 0; j < i.length; j++)
      if (i[j] < n)
        sel.addSelectionInterval(i[j], i[j]);
    tableSetColumnPreferredWidths(table, widths);
    if (sorter != null) {
      sorter.setModel(model);
      callF(setTableModel_fixSorter.get(table), table, sorter);
      //print("Keeping sorter: " + sorter + " Sort keys: " + sortKeys);
      if (sortKeys != null) sorter.setSortKeys(sortKeys);
    }
    table.setRowSorter(sorter);
    callF(setTableModel_after.get(table), table);
  }); }
}



static Pair<JTabbedPane, Integer> enclosingTab(Component _c) {
  return swing(() -> {
    Component c = _c;
    while (c != null) {
      Container p = c.getParent();
      if (p instanceof JTabbedPane)
        return pair(((JTabbedPane) p), ((JTabbedPane) p).indexOfComponent(c));
      c = c.getParent();
    }
    return null;
  });
}




static void setTabTitle(JTabbedPane tabs, int idx, String title) {
  if (tabs != null && idx >= 0) { swing(() -> { 
    if (idx < tabs.getTabCount())
      tabs.setTitleAt(idx, title);
  }); }
}


static String appendBracketedCount(int n, String a) {
  return appendBracketed(a, n2(n));
}

static String appendBracketedCount(String a, int n) {
  return appendBracketedCount(n, a);
}


static String dropTrailingBracketedCount(String s) {
  return replaceAll(s, "\\s?\\([0-9,]+\\)$", "");
}


static String getTabTitle(JTabbedPane tabs, int idx) {
  return tabs == null || idx < 0 ? null : swing(() ->
    idx < tabs.getTabCount() ? tabs.getTitleAt(idx) : null
  );
}


static int tableNumColumns(JTable table) {
  return table == null ? 0 : swing(new F0<Integer>() { public Integer get() { try {  return table.getColumnCount();  } catch (Exception __e) { throw rethrow(__e); } }
  public String toString() { return "return table.getColumnCount();"; }});
}


static void onConceptsChangeAndNow(Runnable r) {
  onConceptsChangeAndNow(db_mainConcepts(), r);
}

static void onConceptsChangeAndNow(Concepts cc, Runnable r) {
  onConceptsChange(cc, r);
  callF(r);
}


static <A extends Concept> Pair<A, Boolean> uniq2(Class<A> c, Object... params) {
  return uniq2(db_mainConcepts(), c, params);
}

static <A extends Concept> Pair<A, Boolean> uniq2(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);
    return pair(x, true);
  }
  return pair(x, false);
} finally { _close(__1); }}


static GlobalID aGlobalIDObj() {
  return asGlobalID(randomID(16));
}

static GlobalID aGlobalIDObj(Random random) {
  return asGlobalID(randomID(random, 16));
}


static <A extends Component> A toComponent(A c) {
  return c;
}

static Component toComponent(Swingable c) {
  return c == null ? null : c.visualize();
}


static <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 JPanel centerAndSouth(final Component c, final Component s) {
  return swing(new F0<JPanel>() { public JPanel get() { try { 
    JPanel panel = new JPanel(new BorderLayout());
    panel.add(BorderLayout.CENTER, wrap(c));
    if (s != null) panel.add(BorderLayout.SOUTH, wrap(s));
    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 int withTopMargin_defaultWidth = 6;

static JPanel withTopMargin(Component c) {
  return withTopMargin(withTopMargin_defaultWidth, c);
}

static JPanel withTopMargin(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(w, 0, 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 <A extends JComponent> A applyMargin(int top, int left, int bottom, int right, A c) {
  return addMargin(top, left, bottom, right, c);
}



static <A extends JComponent> A applyMargin(int w, A c) {
  return addMargin(w, c);
}


static JPanel jrightAlignedLine(final Component... components) {
  return swing(new F0<RightAlignedLine>() { public RightAlignedLine get() { try {  return new RightAlignedLine(components);  } catch (Exception __e) { throw rethrow(__e); } }
  public String toString() { return "return RightAlignedLine(components);"; }});
}

static JPanel jrightAlignedLine(List<? extends Component> components) {
  return jrightAlignedLine(asArray(Component.class, components));
}


static JPanel centerAndEastWithMarginInbetween(Component c, final Component e) {
  return centerAndEast(c, withLeftMargin(e));
}



  static JCheckBox jLiveValueCheckBox(String text, SimpleLiveValue<Boolean> lv) {
    JCheckBox cb = jCheckBox(text);
    bindCheckBoxToLiveValue(cb, lv);
    return cb;
  }


  static JCheckBox jLiveValueCheckBox(String text, IVarWithNotify<Boolean> lv) {
    JCheckBox cb = jCheckBox(text);
    bindCheckBoxToLiveValue(cb, lv);
    return cb;
  }




// TODO: use weak reference to live value - or make each of them only once

static SimpleLiveValue dm_fieldLiveValue(String fieldName) { return dm_fieldLiveValue(dm_current_mandatory(), fieldName); }
static SimpleLiveValue dm_fieldLiveValue(DynModule module, String fieldName) {
  Lock __0 = module.lock; lock(__0); try {
   AutoCloseable __2 = module.enter(); try { // for dm_watchField
  Class type = getFieldType(module, fieldName);
  final SimpleLiveValue value = new SimpleLiveValue(type, get(module, fieldName));
  dm_watchField(fieldName, new Runnable() {  public void run() { try { 
    
    Object o = get(module, fieldName);
    
    value.set(o);
    
  ;
} catch (Exception __e) { throw rethrow(__e); } }  public String toString() { return "ifdef dm_fieldLiveValue_debug\r\n      print(\"dm_fieldLiveValue: setting \" + fi..."; }});
  value.onChange(new Runnable() {  public void run() { try { 
    
    module.setField(fieldName, value.get());
    
  ;
} catch (Exception __e) { throw rethrow(__e); } }  public String toString() { return "ifdef dm_fieldLiveValue_debug\r\n      print(\"dm_fieldLiveValue: setting 2 \" + ..."; }});
  return value;
} finally { _close(__2); }} finally { unlock(__0); } }

static SimpleLiveValue dm_fieldLiveValue(String fieldName, DynModule module) {
  return dm_fieldLiveValue(module, fieldName);
}


static void containerAddFirst(Container c, Component... l) {
  if (c != null) { swing(() -> { 
    for (int i = 0; i < l(l); i++)
      c.add(l[i], i);
    revalidate(c);
  }); }
}


static void setSCPComponent(SingleComponentPanel scp, Component c) {
  if (scp != null) scp.setComponent(c);
}


static void dm_inQ(Runnable r) {
  dm_q().add(r);
}

static void dm_inQ(DynModule mod, Runnable r) {
  dm_q(mod, r);
}


static <A> A dm_evalInQ(F0<A> f) {
  return dm_evalInQ(dm_current_mandatory(), f);
}

static <A> A dm_evalInQ(IF0<A> f) {
  return dm_evalInQ(dm_current_mandatory(), if0ToF0(f));
}

static <A> A dm_evalInQ(DynModule module, F0<A> f) {
  return evalInQ(module.q(), f);
}


static <A> F0<A> if0ToF0(IF0<A> f) {
  return f == null ? null : new F0<A>() { public A get() { try {  return f.get();  } catch (Exception __e) { throw rethrow(__e); } }
  public String toString() { return "return f.get();"; }};
}


static double frac_nonNeg(double d) {
  return mod(d, 1);
}


static Pt pt(int x, int y) {
  return new Pt(x, y);
}

static Pt pt(int x) {
  return new Pt(x, x);
}


static <A> A parentOfType(Component _c, Class<A> theClass) {
  return swing(() -> {
    Component c = _c;
    while (c != null) {
      if (isInstance(theClass, c)) return (A) c;
      c = c.getParent();
    }
    return null;
  });
}


static <A, B> Map<A, B> syncExpiringMap(long standardExpiryTime) {
  return new ExpiringMap2(standardExpiryTime);
}

static <A, B> Map<A, B> syncExpiringMap(double standardExpirySeconds) {
  return syncExpiringMap(toMS(standardExpirySeconds));
}


static List<String> myIPs() {
  return getMyIPs();
}


static String myFirewallIP() {
  return assertIPv4(loadPage("http://botcompany.de:8081/tb-int/my-ip.php"));
}




static SimpleDateFormat simpleDateFormat_GMT(String format) {
  SimpleDateFormat sdf = new SimpleDateFormat(format);
  sdf.setTimeZone(TimeZone.getTimeZone("GMT"));
  return sdf;
}




static String formatGMT_24(long time) {
  SimpleDateFormat sdf = new SimpleDateFormat("HH:mm");
  sdf.setTimeZone(TimeZone.getTimeZone("GMT"));
  return sdf.format(time) + " GMT";
}


static 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 <A> A setAll(A o, Map<String, Object> fields) {
  if (fields == null) return o;
  for (String field : keys(fields))
    set(o, field, fields.get(field));
  return o;
}

static <A> A setAll(A o, Object... values) {
  //values = expandParams(c.getClass(), values);
  failIfOddCount(values);
  for (int i = 0; i+1 < l(values); i += 2) {
    String field = (String) values[i];
    Object value = values[i+1];
    set(o, field, value);
  }
  return o;
}


static String formatDate() {
  return formatDate(now());
}

static String formatDate(long timestamp) {
  return timestamp == 0 ? "-" : str(new Date(timestamp));
}

static String formatDate(long timestamp, String format, TimeZone tz) {
  return simpleDateFormat(format, tz).format(timestamp);
}


static Rectangle maximumWindowBounds() {
  return maxWindowBounds();
}


static String programIDPlusHome() {
  return programIDPlusHome(programID(), userHomeIfNotActual());
}

static String programIDPlusHome(String programID, File home) {
  return programIDPlusHome(programID, f2s(home));
}

static String programIDPlusHome(String programID, String home) {
  if (home != null)
    programID += " " + quote(home);
  return programID;
}


static List<JFrame> activateMyFrames() {
  final List<JFrame> l = myFrames();
  { swing(() -> { 
    for (JFrame f : l)
      activateFrame(f);
  }); }
  return l;
}


static String programName() {
  return getProgramName();
}


static void ensureConceptClassIsIndexed(Class<? extends Concept> c) { ensureConceptClassIsIndexed(db_mainConcepts(), c); }
static void ensureConceptClassIsIndexed(Concepts cc, Class<? extends Concept> c) {
  if (cc != null && c != null && !isConceptClassIndexed(cc, c))
    indexRandomConceptField(cc, c);
}


static boolean boolParam(ThreadLocal<Boolean> tl) {
  return boolOptParam(tl);
}



// defaults to false
static boolean boolParam(Object[] __, String name) {
  return boolOptParam(__, name);
}



static boolean boolParam(String name, Object[] __) {
  return boolOptParam(name, __);
}


static <A> List<A> listMinusList(Collection<A> l, Collection stuff) {
  if (empty(stuff) && l instanceof List) return (List) l;
  List<A> l2 = cloneList(l);
  for (Object o : stuff)
    l2.remove(o);
  return l2;
}


static boolean sexyTable_drag = false;

static JTable sexyTable() {
  final JTable table = sexyTableWithoutDrag();
  if (sexyTable_drag)
    tableEnableTextDrag(table); // TODO: seems to interfere with double clicks
  return table;
}


static void deleteConcept_sync(long id) {
  deleteConcept_sync(db_mainConcepts(), id);
}

static void deleteConcept_sync(Concepts concepts, long id) {
  withDBLock(concepts, new Runnable() {  public void run() { try {  concepts.deleteConcept(id) ;
} catch (Exception __e) { throw rethrow(__e); } }  public String toString() { return "concepts.deleteConcept(id)"; }});
}

static void deleteConcept_sync(Concept c) {
  if (c != null) withDBLock(c._concepts, new Runnable() {  public void run() { try {  c.delete() ;
} catch (Exception __e) { throw rethrow(__e); } }  public String toString() { return "c.delete()"; }});
}

static void deleteConcept_sync(Concept.Ref ref) {
  if (ref != null) deleteConcept_sync(ref.get());
}



static Object renderForTable(Object o) {
  { var __1= toBufferedImageOpt(o); if (__1 != null) return __1; }
  if (o instanceof String && containsNewLine((String) o))
    return escapeNewLines((String) o);
  return o;
}


static Object renderForTable_noStruct(Object o) {
  { var __1= toBufferedImageOpt(o); if (__1 != null) return __1; }
  if (o instanceof String && containsNewLine((String) o))
    return escapeNewLines(dropTrailingNewLine((String) o));
  if (o instanceof Collection) return joinWithComma((Collection) o);
  return strOrNull(o);
}


static <A> List<A> reverseInPlace(List<A> l) {
  return reverseList(l);
}


static <A> A postProcess(Object f, A a) {
  return callPostProcessor(f, a);
}

static <A> A postProcess(IF1<A, A> f, A a) {
  return callPostProcessor(f, a);
}


static void fillTableWithData(final JTable table, List<List> rows, List<String> colNames) {
  fillTableWithData(table, rows, toStringArray(colNames));
}

// thread-safe
static void fillTableWithData(final JTable table, List<List> rows, String... colNames) {
  final DefaultTableModel model = fillTableWithData_makeModel(rows, colNames);
  
  // TODO: keep model if columns identical?
  setTableModel(table, model);
}

static DefaultTableModel fillTableWithData_makeModel(List<List> rows, String... colNames) {
  Pair<Object[][], Object[]> p = fillTableWithData_makeData(rows, colNames);
  return new DefaultTableModel(p.a, p.b) {
    public Class getColumnClass(int column) {
      return or(_getClass(getValueAt(0, column)), String.class);
    }
    
    public boolean isCellEditable(int rowIndex, int columnIndex) {
      return false;
    }
  };
}



static JTable dataToTable_uneditable(Object data, final JTable table) {
  return dataToTable_uneditable(table, data);
}

static JTable dataToTable_uneditable(final JTable table, final Object data) {
  if (table != null) { swing(() -> { 
    dataToTable(table, data, true);
    makeTableUneditable(table);
  }); }
  return table;
}

static JTable dataToTable_uneditable(final Object data) {
  return dataToTable_uneditable(showTable(), data);
}

static JTable dataToTable_uneditable(Object data, String title) {
  return dataToTable_uneditable(showTable(title), data);
}


static void tableDependButtons(JTable table, List<? extends Component> buttons) {
  for (Component c : buttons)
    if (c instanceof JButton) {
      JButton b =  (JButton) c;
      onTableSelectionChangedAndNow(table, () -> b.setEnabled(table.getSelectedRow() >= 0));
    }
}


static Object selectedTableCell(JTable t, int col) {
  return getTableCell(t, selectedTableRow(t), col);
}

static Object selectedTableCell(final JTable t) {
  return swing(new F0<Object>() { public Object get() { try {  return selectedTableCell(t, t.getSelectedColumn());  } catch (Exception __e) { throw rethrow(__e); } }
  public String toString() { return "return selectedTableCell(t, t.getSelectedColumn());"; }});
}

static Object selectedTableCell(final JTable t, final String colName) {
  return swing(new F0<Object>() { public Object get() { try {  return selectedTableCell(t, tableColumnViewIndex(t, colName));  } catch (Exception __e) { throw rethrow(__e); } }
  public String toString() { return "return selectedTableCell(t, tableColumnViewIndex(t, colName));"; }});
}


static <A extends Concept> A ccopyFields2(Concept x, A y, Iterable<String> fields) {
  if (x == null || y == null) return y;
  for (String field : unnull(fields)) {
    Object o = cget(x, field);
    if (o != null)
      cset(y, field, o);
  }
  return y;
}


static <A, B extends A> Set<A> setMinusSet(Set<A> l, Collection<B> stuff) {
  if (empty(stuff)) return l;
  Set<B> set = asSet(stuff);
  Set<A> l2 = similarEmptySet(l);
  for (A a : l) if (!set.contains(a)) l2.add(a);
  return l2;
}

static <A, B extends A> Set<A> setMinusSet(Collection<A> l, Collection<B> stuff) {
  return setMinusSet(asSet(l), stuff);
}



static String[] conceptFields_drop = {"className", "fieldValues", "id", "created", "_modified", "refs", "backRefs", "_concepts"};

static Set<String> conceptFields(Concept c) {
  return setMinus(mergeSets(allNonStaticNonTransientFields(c), keys(c.fieldValues)), conceptFields_drop);
}

static Set<String> conceptFields(Class<? extends Concept> c) {
  return setMinus(allNonStaticNonTransientFields(c), conceptFields_drop);
}


static Object getMCOpt(String field) {
  return getOptMC(field);
}


static void setMCOpt(String field, Object value) {
  setOptMC(field, value);
}


static JPanel showFormTitled_customLayout(final F1<Container, Dimension> layouter, final String title, final Object... parts) {
  return showFormTitled_customArrangement(false, new F1<List<JComponent>, JPanel>() { public JPanel get(List<JComponent> components) { try { 
    return customLayoutPanel(layouter, components);  } catch (Exception __e) { throw rethrow(__e); } }
  public String toString() { return "customLayoutPanel(layouter, components)"; }}, title, parts);
}


static int formLayouter1_yPlus = 5; // make higher (bug fixing)
static int formLayouter1_fixer2 = 0;

static F1<Container, Dimension> formLayouter1() {
  final int yplus = formLayouter1_yPlus, fixer2 = formLayouter1_fixer2;
  return new F1<Container, Dimension>() { public Dimension get(Container parent) { try { 
    List<Component> l = getComponents(parent);
    BitSet bigOnes = new BitSet();
    for (int i = 0; i < l(l); i++)
      if (containsATextArea(l.get(i))) add(bigOnes, i);
      
    int nBigOnes = bigOnes.cardinality();
    int mandatoryHeight = totalPreferredHeight(listWithoutIndicesInBitSet(l, bigOnes));
    int gap = 4, outerSpacing = 5;
    Dimension size = parent.getSize();
    int gapsAndMargins = outerSpacing*2-(l(l)-1)*gap;
    int totalSpace = size.height-gapsAndMargins-fixer2;
    int liberalSpace = totalSpace-mandatoryHeight;
    double perBigOne = doubleRatio(liberalSpace, nBigOnes);
    double y = outerSpacing;
    for (int i = 0; i < l(l); i++) {
      Component c = l.get(i);
      boolean big = contains(bigOnes, i);
      double h = big ? perBigOne : c.getPreferredSize().height;
      int actualY = iround(y);
      c.setBounds(10, actualY, size.width-outerSpacing*2, iround(y+h)-actualY);
      y += h+gap;
    }
    
    // return preferred size
    Dimension pref = componentsBoundingSize(parent, outerSpacing);
    
    if (parent.getHeight() <= 0) { // pre-showing - maybe we should always do this
      int tph = totalPreferredHeight(l);
      pref.height = tph+gapsAndMargins+yplus;
      
    }
    return pref;
   } catch (Exception __e) { throw rethrow(__e); } }
  public String toString() { return "L<Component> l = getComponents(parent);\r\n    new BitSet bigOnes;\r\n    for i o..."; }};
}


static Object[] concatArrays(Object[]... arrays) {
  int l = 0;
  for (Object[] a : arrays) l += l(a);
  Object[] x = new Object[l];
  int i = 0;
  for (Object[] a : arrays) if (a != null) {
    System.arraycopy(a, 0, x, i, l(a));
    i += l(a);
  }
  return x;
}



static int selectedTableRow(final JTable t) {
  return t == null ? -1 : swing(new F0<Integer>() { public Integer get() { try {  return t.getSelectedRow();  } catch (Exception __e) { throw rethrow(__e); } }
  public String toString() { return "return t.getSelectedRow();"; }});
}


static int tableRows(JTable table) {
  return (int) swingCall(table, "getRowCount");
}


static JCheckBox centerCheckBox(JCheckBox cb) {
  return setHorizontalAlignment(SwingConstants.CENTER, cb);
}


static JCheckBox jCheckBox() {
  return swingNu(JCheckBox.class);
}

static JCheckBox jCheckBox(boolean checked) {
  return swingNu(JCheckBox.class, "", checked);
}

static JCheckBox jCheckBox(String text, boolean checked) {
  return swingNu(JCheckBox.class, text, checked);
}

static JCheckBox jCheckBox(String text) {
  return swingNu(JCheckBox.class, text);
}
  
static JCheckBox jCheckBox(String text, boolean checked, Object onChange) {
  JCheckBox cb = jCheckBox(text, checked);
  cb.setText(text);
  return cb;
}
  
// onChange can be a Runnable or a voidfunc(bool)
static JCheckBox jCheckBox(boolean checked, final Object onChange) {
  final JCheckBox cb = jCheckBox(checked);
  cb.addChangeListener(new ChangeListener() {
    public void stateChanged(ChangeEvent e) {
      pcallF(onChange, cb.isSelected());
    }
  });
  return cb;
}

static JCheckBox jCheckBox(boolean checked, String text, IVF1<Boolean> onChangeAndNow) {
  var cb = jCheckBox(text, checked);
  onChangeAndNow(cb, new Runnable() {  public void run() { try {  onChangeAndNow.get(isChecked(cb)); 
} catch (Exception __e) { throw rethrow(__e); } }  public String toString() { return "onChangeAndNow.get(isChecked(cb));"; }});
  return cb;
}


static JTextArea newTypeWriterTextArea() {
  return newTypeWriterTextArea("");
}

static JTextArea newTypeWriterTextArea(String text) {
  return withTypeWriterFont(jTextArea(text));
}


static JComboBox jcombobox(final String... items) {
  return swing(new F0<JComboBox>() { public JComboBox get() { try {  return new JComboBox(items);  } catch (Exception __e) { throw rethrow(__e); } }
  public String toString() { return "return new JComboBox(items);"; }});
}

static JComboBox jcombobox(Collection<String> items) {
  return jcombobox(toStringArray(items));
}

static JComboBox jcombobox(Collection<String> items, String selectedItem) {
  return selectItem(selectedItem, jcombobox(items));
}

static JComboBox jcombobox(String selectedItem, Collection<String> items) {
  return jcombobox(items, selectedItem);
}


static List collectField(Iterable c, String field) {
  List l = new ArrayList();
  if (c != null) for (Object a : c)
    l.add(getOpt(a, field));
  return l;
}

static List collectField(String field, Iterable c) {
  return collectField(c, field);
}


static JComponent unwrapScrollPane(JScrollPane sp) {
  return sp == null ? null : (JComponent) sp.getViewport().getView();
}


static float toFloat(Object o) {
  if (o == null) return 0f;
  if (o instanceof Number) return ((Number) o).floatValue();
  if (o instanceof Boolean) return ((Boolean) o).booleanValue() ? 1f : 0f;
  throw fail("Not convertible to float: " + _getClass(o));
}


static Pt parsePt(String s) {
  var l = parseInts(splitAtComma_trim(s));
  return empty(l) ? null : pt(first(l), second(l));
}


static Rect parseRect(String s) {
  List<String> tok = javaTokC(s);
  assertEquals(7, l(tok));
  return new Rect(parseInt(tok.get(0)), parseInt(tok.get(2)),
    parseInt(tok.get(4)), parseInt(tok.get(6)));
}


// returns from C to C
static String jextract(String pat, String s) {
  return jextract(pat, javaTok(s));
}

static String jextract(String pat, List<String> tok) {
  List<String> tokpat = javaTok(pat);
  jfind_preprocess(tokpat);
  int i = jfind(tok, tokpat);
  if (i < 0) return null;
  int j = i + l(tokpat) - 2;
  return joinSubList(tok, i, j);
}



static boolean imagesIdentical(BufferedImage img1, BufferedImage img2) {
  if (img1 == img2) return true;
  if (img1 == null) return img2 == null;
  if (img2 == null) return false;
  
  int w = img1.getWidth(), h = img1.getHeight();
  if (w != img2.getWidth() || h != img2.getHeight()) return false;
  
  var gp1 = grabbableIntPixels_fastOrSlow(img1);
  var gp2 = grabbableIntPixels_fastOrSlow(img2);

  int[] pixels1 = gp1.data, pixels2 = gp2.data;
  int scanlineExtra1 = gp1.scanlineStride-w;
  int scanlineExtra2 = gp2.scanlineStride-w;
  int i1 = gp1.offset, i2 = gp2.offset;

  var ping = pingSource();
  for (int y = 0; y < h; y++) {
    for (int x = 0; x < w; x++)
      if (pixels1[i1++] != pixels2[i2++])
        return false;

    i1 += scanlineExtra1;
    i2 += scanlineExtra2;
    { if (ping != null) ping.get(); }
  }

  return true;
}


static <A> List<A> listMinusSet(Iterable<A> l, Collection<? extends A> stuff) {
  if (l == null) return null;
  if (empty(stuff)) return asList(l);
  Set<? extends A> set = asSet(stuff);
  List<A> l2 = new ArrayList();
  for (A a : l) if (!set.contains(a)) l2.add(a);
  return l2;
}

static <A> List<A> listMinusSet(Iterable<A> l, Collection<A> stuff, Collection<? extends A> stuff2) {
  return listMinusSet(listMinusSet(l, stuff), stuff2);
}


static <A> List<A> listIntersectSet(Collection<A> a, Collection<A> b) {
  return listSetIntersection(a, b);
}


static <A> void setAddAll(Collection<A> a, Collection<A> b) {
  for (A x : b)
    setAdd(a, x);
}


static Set similarEmptySet(Iterable m) {
  if (m instanceof TreeSet) return new TreeSet(((TreeSet) m).comparator());
  if (m instanceof LinkedHashSet) return new LinkedHashSet();
  
  return new HashSet();
}

static Set similarEmptySet(Map m) {
  if (m instanceof TreeMap) return new TreeSet(((TreeMap) m).comparator());
  if (m instanceof LinkedHashMap) return new LinkedHashSet();
  
  return new HashSet();
}


static Map<String, Object> rawTableLineAsMap(JTable tbl, int row) {
  if (row >= 0 && row < tbl.getModel().getRowCount()) {
    Map<String, Object> map = litorderedmap(); // keep order of columns
    for (int i = 0; i < tbl.getModel().getColumnCount(); i++)
      mapPut(map, tbl.getModel().getColumnName(i),
        tbl.getModel().getValueAt(row, i));
    return map;
  }
  return null;
}


static boolean showTable_searcher = true;

static JTable showTable(Object data) {
  return dataToTable_uneditable(data);
}

static JTable showTable(String title, Object data) {
  return showTable(data, title);
}

static JTable showTable(Object data, String title) {
  return dataToTable_uneditable(data, title);
}

static JTable showTable(JTable table, Object data) {
  return showTable(table, data, autoFrameTitle());
}

static JTable showTable(Object data, JTable table) {
  return showTable(table, data);
}

static JTable showTable(JTable table, Object data, String title) {
  if (table == null)
    table = showTable(data, title);
  else {
    setFrameTitle(table, title);
    dataToTable_uneditable(table, data);
  }
  return table;
}

static JTable showTable() {
  return showTable(new ArrayList<List<String>>(), new ArrayList<String>());
}

static JTable showTable(String title) {
  return showTable(new ArrayList<List<String>>(), new ArrayList<String>(), title);
}

static JTable showTable(List<List<String>> rows, List<String> cols) {
  return showTable(rows, cols, autoFrameTitle());
}
  
static JTable showTable(List<List<String>> rows, List<String> cols, String title) {
  JTable tbl = sexyTable();
  fillTableWithStrings(tbl, rows, cols);
  showFrame(title, tbl);
  return tbl;
}


static ThreadLocal<Boolean> dataToTable_useStruct = threadLocalWithDefault(true);

static void dataToTable_dynSet(List l, int i, Object s) {
  while (i >= l.size()) l.add("");
  l.set(i, s);
}

static List dataToTable_makeRow(Object x, List<String> cols) {
  if (instanceOf(x, "DynamicObject"))
    x = get_raw(x, "fieldValues");

  if (x instanceof Map) {
    Map m =  (Map) x;
    List row = new ArrayList();
    for (Object _field : keysWithoutHidden(m)) {
      String field =  (String) _field;
      Object value = m.get(field);
      int col = cols.indexOf(field);
      if (col < 0) {
        cols.add(field);
        col = cols.size()-1;
      }
      dataToTable_dynSet(row, col, dataToTable_wrapValue(value));
    }
    return row;
  }
  
  // XXX new
  if (x instanceof List)
    return allToString((List) x);
    
  return litlist(structureOrText(x));
}

static Object dataToTable_wrapValue(Object o) {
  if (o instanceof BufferedImage) return o;
  if (o instanceof MakesBufferedImage) return ((MakesBufferedImage) o).getBufferedImage();
  
    if (o instanceof RGBImage) return o; // huh?
  
  if (o instanceof Boolean) return o;
  return dataToTable_useStruct.get() ? structureOrTextForUser(o) : strOrNull(o);
}


static String structureOrTextForUser(Object o) {
  return o == null ? "" : o instanceof String ? (String) o : structureForUser(o);
}


static JPanel westAndCenterWithMargin(Component w, Component c) {
  return westAndCenter(withRightMargin(w), c);
}

static JPanel westAndCenterWithMargin(int margin, Component w, Component c) {
  return westAndCenter(withRightMargin(margin, w), c);
}


static boolean boolOptParam(ThreadLocal<Boolean> tl) {
  return isTrue(optPar(tl));
}

// defaults to false
static boolean boolOptParam(Object[] __, String name) {
  return isTrue(optParam(__, name));
}

static boolean boolOptParam(String name, Object[] __) {
  return boolOptParam(__, name);
}

static boolean boolOptParam(String name, Map __) {
  return isTrue(optPar(name, __));
}


static 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 Map<String, Integer> tableColumnWidthsByName(JTable table) {
  TableColumnModel tcm = table.getColumnModel();
  if (tcm == null) return null;
  int n = tcm.getColumnCount();
  TreeMap<String, Integer> map = new TreeMap();
  for (int i = 0; i < n; i++) {
    TableColumn tc = tcm.getColumn(i);
    map.put(str(tc.getHeaderValue()), tc.getWidth());
  }
  return map;
}


static boolean tableSetColumnPreferredWidths_debug = false;

static void tableSetColumnPreferredWidths(final JTable table, final Map<String, Integer> widths) {
  if (table == null || widths == null) return;
  { swing(() -> {  try {
    TableColumnModel tcm = table.getColumnModel();
    int n = tcm.getColumnCount();
    for (int i = 0; i < n; i++) {
      TableColumn tc = tcm.getColumn(i);
      Integer w = widths.get(str(tc.getHeaderValue()));
      if (w != null) {
        tc.setPreferredWidth(w);
        if (tableSetColumnPreferredWidths_debug)
          print("Setting preferred width of column " + i + " to " + w);
      }
    }
  } catch (Throwable __e) { pcallFail(__e); }}); }
}

static void tableSetColumnPreferredWidths(JTable table, Object... widths) {
  tableSetColumnPreferredWidths(table, litorderedmap(widths));
}



static String appendBracketed(Object o) {
  String b = strOrNull(o);
  return empty(b) ? "" : "" + " (" + b + ")";
}

static String appendBracketed(String a, String b) {
  return a + appendBracketed(b);
}


static <A> List<A> replaceAll(List<A> l, final A a, final A b) {
  return map(l, new F1<A, A>() { public A get(A x) { try {  return eq(x, a) ? b : x;  } catch (Exception __e) { throw rethrow(__e); } }
  public String toString() { return "eq(x, a) ? b : x"; }});
}

static String replaceAll(String s, String a, String b) {
  return s == null ? null : s.replaceAll(a, b);
}


static void onConceptsChange(Runnable r) {
  onConceptsChange(db_mainConcepts(), r);
}

static void onConceptsChange(Concepts cc, Runnable r) {
  cc.addConceptIndex(simpleConceptIndex(r));
  cc.onAllChanged.add(r);
}


static GlobalID asGlobalID(String id) {
  return id == null ? null : new GlobalID(id);
}




static <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 <A extends JComponent> A addMargin(int w, A c) {
  return addMargin(w, w, w, w, c);
}



static int withLeftMargin_defaultWidth = 6;

static JPanel withLeftMargin(Swingable c) { return withLeftMargin(toComponent(c)); }

static JPanel withLeftMargin(Component c) {
  return withLeftMargin(withLeftMargin_defaultWidth, c);
}

static JPanel withLeftMargin(int margin, Swingable c) { return withLeftMargin(margin, toComponent(c)); }

static JPanel withLeftMargin(int margin, 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 <A extends JCheckBox> A bindCheckBoxToLiveValue(A cb, SimpleLiveValue<Boolean> lv) {
    bindChangeListenerToComponent(cb, lv, new Runnable() {  public void run() { try { 
      
      setChecked(cb, isTrue(lv.get()));
      
    ;
} catch (Exception __e) { throw rethrow(__e); } }  public String toString() { return "ifdef bindCheckBoxToLiveValue_debug\r\n        print(\"bindCheckBoxToLiveValue: ..."; }});
    onChange(cb, new Runnable() {  public void run() { try { 
      
      lv.set(isChecked(cb));
      
    ;
} catch (Exception __e) { throw rethrow(__e); } }  public String toString() { return "ifdef bindCheckBoxToLiveValue_debug\r\n        print(\"bindCheckBoxToLiveValue: ..."; }});
    return cb;
  }


  static <A extends JCheckBox> A bindCheckBoxToLiveValue(A cb, IVarWithNotify<Boolean> lv) {
    bindChangeListenerToComponent(cb, lv, new Runnable() {  public void run() { try { 
      
      setChecked(cb, isTrue(lv.get()));
      
    ;
} catch (Exception __e) { throw rethrow(__e); } }  public String toString() { return "ifdef bindCheckBoxToLiveValue_debug\r\n        print(\"bindCheckBoxToLiveValue: ..."; }});
    onChange(cb, new Runnable() {  public void run() { try { 
      
      lv.set(isChecked(cb));
      
    ;
} catch (Exception __e) { throw rethrow(__e); } }  public String toString() { return "ifdef bindCheckBoxToLiveValue_debug\r\n        print(\"bindCheckBoxToLiveValue: ..."; }});
    return cb;
  }




static <A> A evalInQ(Q q, IF0<A> f) {
  return evalInQ(q, if0ToF0(f));
}

static <A> A evalInQ(Q q, F0<A> f) {
  if (isInQ(q)) return callF(f);
  
  final Var<Either<A, Throwable>> var = new Var();
  
  q.add(new Runnable() {  public void run() { try { 
    try {
      var.set(eitherA(callF(f)));
    } catch (Throwable e) {
      var.set(eitherB(e));
    }
  
} catch (Exception __e) { throw rethrow(__e); } }  public String toString() { return "try {\r\n      var.set(eitherA(callF(f)));\r\n    } catch (Throwable e) {\r\n      ..."; }});
  
  return returnOrThrow_either(waitForVarToBeNotNull(var));
}


static List<String> getMyIPs() { try {
  TreeSet<String> ips = new TreeSet();
  Enumeration<NetworkInterface> interfaces = NetworkInterface.getNetworkInterfaces();
  while (interfaces.hasMoreElements()) {
    NetworkInterface iface = interfaces.nextElement();
    // filters out 127.0.0.1 and inactive interfaces
    if (iface.isLoopback() || !iface.isUp())
        continue;

    Enumeration<InetAddress> addresses = iface.getInetAddresses();
    while(addresses.hasMoreElements()) {
      InetAddress addr = addresses.nextElement();
      String ip = addr.getHostAddress();
      if (ip.startsWith("127.")) continue;
      ips.add(ip);
    }
  }
  return new ArrayList<String>(ips);
} catch (Exception __e) { throw rethrow(__e); } }


static String assertIPv4(String s) {
  assertTrue(s, isIPv4(s));
  return s;
}


static void failIfOddCount(Object... list) {
  if (odd(l(list)))
    throw fail("Odd list size: " + list);
}


static Rectangle maxWindowBounds() {
  return GraphicsEnvironment.getLocalGraphicsEnvironment().getMaximumWindowBounds();
}


static String userHomeIfNotActual() {
  String home = userHome();
  return eq(home, actualUserHome()) ? null : home;
}


static 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);
      
    // My glorious Windows hack
    // See: https://stackoverflow.com/questions/309023/how-to-bring-a-window-to-the-front
    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 <A extends Concept> boolean isConceptClassIndexed(Class<A> c) {
  return isConceptClassIndexed(db_mainConcepts(), c);
}

static <A extends Concept> boolean isConceptClassIndexed(Concepts concepts, Class<A> c) {
  return concepts.conceptCounterForClass(c) != null;
}



static void indexRandomConceptField(Class<? extends Concept> c) { indexRandomConceptField(db_mainConcepts(), c); }
static void indexRandomConceptField(Concepts cc, Class<? extends Concept> c) {
  String field = or(first(conceptFields(c)), "_dummy");
  print("Indexing " + c + "." + field);
  indexConceptField(cc, c, field);
  assertTrue("Concept class indexed", isConceptClassIndexed(cc, c));
  { long _startTime_0 = sysNow(); try {   print("Got " + nConcepts(countConcepts(cc, c))); } finally { _startTime_0 = sysNow()-_startTime_0; saveTiming(_startTime_0); } }
}


static JTable sexyTableWithoutDrag() {
  final JTable table = tableWithToolTips();

  tablePopupMenu(table, sexyTableWithoutDrag_popupMenuMaker(table));
  
  // Disable Ctrl+PageUp and Ctrl+PageDown
  
  table.getInputMap().put(KeyStroke.getKeyStroke(KeyEvent.VK_PAGE_UP, InputEvent.CTRL_MASK), "none");
  //table.getInputMap().put(KeyStroke.getKeyStroke(KeyEvent.VK_PAGE_DOWN, InputEvent.CTRL_MASK), "none");
  /*table.registerKeyboardAction(
    null,
    KeyStroke.getKeyStroke(KeyEvent.VK_PAGE_UP, InputEvent.CTRL_MASK),
    JComponent.WHEN_ANCESTOR_OF_FOCUSED_COMPONENT
  );*/
  table.getInputMap(JComponent.WHEN_ANCESTOR_OF_FOCUSED_COMPONENT)
    .put(KeyStroke.getKeyStroke(KeyEvent.VK_PAGE_UP, InputEvent.CTRL_MASK), "none");
  table.getInputMap(JComponent.WHEN_FOCUSED)
    .put(KeyStroke.getKeyStroke(KeyEvent.VK_PAGE_UP, InputEvent.CTRL_MASK), "none");
  table.getInputMap(JComponent.WHEN_ANCESTOR_OF_FOCUSED_COMPONENT)
    .put(KeyStroke.getKeyStroke(KeyEvent.VK_PAGE_UP, InputEvent.CTRL_MASK), "none");
  table.getInputMap(JComponent.WHEN_IN_FOCUSED_WINDOW)
    .put(KeyStroke.getKeyStroke(KeyEvent.VK_PAGE_UP, InputEvent.CTRL_MASK), "none");
  ((InputMap) UIManager.get("Table.ancestorInputMap")).put(KeyStroke.getKeyStroke(KeyEvent.VK_PAGE_UP, InputEvent.CTRL_MASK), "none");
    
  return table;
}

static VF2<JPopupMenu, Integer> sexyTableWithoutDrag_popupMenuMaker(JTable t) {
  final WeakReference<JTable> ref = weakRef(t);
  return new VF2<JPopupMenu, Integer>() { public void get(JPopupMenu menu, Integer row) { try { 
    final JTable table = ref.get();
    final String item = first(getTableLine(table, row));
    MouseEvent e = tablePopupMenu_mouseEvent.get();
    final int col = table.columnAtPoint(e.getPoint());
    final Object value = table.getModel().getValueAt(row, col);
    //print("Cell type: " + getClassName(value));

    if (value instanceof ImageIcon) {
      addMenuItem(menu, "Copy image to clipboard", new Runnable() {  public void run() { try { 
        copyImageToClipboard(((ImageIcon) value).getImage());
      
} catch (Exception __e) { throw rethrow(__e); } }  public String toString() { return "copyImageToClipboard(((ImageIcon) value).getImage());"; }});
    } else {
      final String text = str(value);
      addMenuItem(menu, "Copy text to clipboard", new Runnable() {  public void run() { try { 
        copyTextToClipboard(text);
        print("Copied text to clipboard: " + quote(text));
      
} catch (Exception __e) { throw rethrow(__e); } }  public String toString() { return "copyTextToClipboard(text);\r\n        print(\"Copied text to clipboard: \" + quot..."; }});
    }
    
    addMenuItem(menu, "Set row height...", new Runnable() {  public void run() { try { 
      final JTextField tf = jTextField(table.getRowHeight());
      showTitledForm("Set row height",
        "Pixels", tf, new Runnable() {  public void run() { try { 
          table.setRowHeight(parseInt(trim(tf.getText())))
        ;
} catch (Exception __e) { throw rethrow(__e); } }  public String toString() { return "table.setRowHeight(parseInt(trim(tf.getText())))"; }});
    
} catch (Exception __e) { throw rethrow(__e); } }  public String toString() { return "final JTextField tf = jTextField(table.getRowHeight());\r\n      showTitledForm..."; }});
   } catch (Exception __e) { throw rethrow(__e); } }
  public String toString() { return "final JTable table = ref!;\r\n    final S item = first(getTableLine(table, row)..."; }};
}




static void tableEnableTextDrag(final JTable table) {
  TransferHandler th = new TransferHandler() {
    @Override
    public int getSourceActions(JComponent c) { return COPY; }

    @Override
    protected Transferable createTransferable(JComponent c) {
      //print("Row/Column: " + table.getSelectedRow() + " / " + table.getSelectedColumn());
      Object o = selectedTableCell(table);
      //print("Value: " + o);
      return new StringSelection(str(o));
    }
  };
  tableEnableDrag(table, th);
}


static 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);
  
  // Keep this because it also works on imported objects
  if (eqOneOf(c, "main$BWImage", "main$RGBImage"))
    return (BufferedImage) call(o, "getBufferedImage");
 
  
  
  return null;
}


static String escapeNewLines(String s) {
  return s == null ? null : fixNewLines(s).replace("\n", " | ");
}


static String dropTrailingNewLine(String s) {
  int l = l(s);
  if (l > 0 && s.charAt(l-1) == '\n') --l;
  if (l > 0 && s.charAt(l-1) == '\r') --l;
  return takeFirst(s, l);
}


static <A> List<A> reverseList(List<A> l) {
  Collections.reverse(l);
  return l;
}


static <A> A callPostProcessor(Object f, A a) {
  return f == null ? a : (A) callF(f, a);
}

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


static Pair<Object[][], Object[]> fillTableWithData_makeData(List<List> rows, List<String> colNames) {
  return fillTableWithData_makeData(rows, asStringArray(colNames));
}

static Pair<Object[][], Object[]> fillTableWithData_makeData(List<List> rows, String... colNames) {
  Object[][] data = new Object[rows.size()][];
  int w = 0;
  for (int i = 0; i < rows.size(); i++) {
    List l = rows.get(i);
    Object[] r = new Object[l.size()];
    for (int j = 0; j < l.size(); j++) {
      Object o = l.get(j);
      
      //print ifdef fillTableWithData_makeData_debug("fillTable " + getClass(o));
      
      if (o instanceof BufferedImage) o = imageIcon((BufferedImage) o);
      
        if (o instanceof RGBImage) o = imageIcon((RGBImage) o);
      
      /*if (o cast File)
        o = f2s(o);*/
      r[j] = o;
    }
    data[i] = r;
    w = Math.max(w, l.size());
  }
  Object[] columnNames = new Object[w];
  for (int i = 0; i < w; i++)
    columnNames[i] = i < l(colNames) ? colNames[i] : "?";
  return pair(data, columnNames);
}



static void makeTableUneditable(JTable table) {
  for (int c = 0; c < table.getColumnCount(); c++) {
    Class<?> col_class = table.getColumnClass(c);
    //O ed = table.getDefaultEditor(col_class);
    //print("Column " + c + " class: " + col_class + " editor: " + ed);
    table.setDefaultEditor(col_class, null); // remove editor
  }
}


static void onTableSelectionChangedAndNow(final JTable table, final Runnable r) {
  { swing(() -> { 
    table.getSelectionModel().addListSelectionListener(new ListSelectionListener() {
      public void valueChanged(ListSelectionEvent e) {
        // swingLater helps us avoid spurios selection changes during table updates
        swingLater(r);
      }
    });
    callF(r);
  }); }
}


static int tableColumnViewIndex(final JTable t, final String colName) {
  return swing(new F0<Integer>() { public Integer get() { try { 
    return t.convertColumnIndexToView(t.getColumn(colName).getModelIndex());
   } catch (Exception __e) { throw rethrow(__e); } }
  public String toString() { return "return t.convertColumnIndexToView(t.getColumn(colName).getModelIndex());"; }});
}


static <A> Set<A> setMinus(Set<A> set, Object... stuff) {
  Set s2 = cloneSet(set);
  for (Object o : stuff)
    s2.remove(o);
  return s2;
}


static <A> Set<A> mergeSets(Collection<A>... l) {
  return joinSets(l);
}


static Set<String> allNonStaticNonTransientFields(Object o) {
  TreeSet<String> fields = new TreeSet();
  Class _c = _getClass(o);
  do {
    for (Field f : _c.getDeclaredFields())
      if ((f.getModifiers() & (Modifier.STATIC|Modifier.TRANSIENT)) == 0)
        fields.add(f.getName());
    _c = _c.getSuperclass();
  } while (_c != null);
  return fields;
}


static void setOptMC(String field, Object value) {
  setOpt(mc(), field, value);
}


static JPanel showFormTitled_customArrangement(final boolean internalFrame, final F1<List<JComponent>, JPanel> arrange, final String title, final Object... _parts) {
  return swing(new F0<JPanel>() { public JPanel get() { try { 
    List<JComponent> out = showForm_arrange1(showForm_makeComponents(internalFrame, _parts));
    JPanel panel = callF(arrange, out);
    showForm_makeFrame(title, panel);
    return panel;
   } catch (Exception __e) { throw rethrow(__e); } }
  public String toString() { return "L<JComponent> out = showForm_arrange1(showForm_makeComponents(internalFrame, ..."; }});
}


// layouter: voidfunc(Container)
// or func(Container) -> Dimension [preferred size]
// or func(Container) -> Pair(Dimension, Dimension) [preferred, minimum]
static JPanel customLayoutPanel(final Object layouter) {
  return jpanel(layoutManagerFromFunction(layouter));
}

static JPanel customLayoutPanel(final Object layouter, final List<? extends Component> components) {
  return addAllComponents(customLayoutPanel(layouter), components);
}

static JPanel customLayoutPanel(LayoutManager layouter, Component... components) {
  return addAllComponents(customLayoutPanel(layouter), components);
}


static boolean containsATextArea(Component c) {
  return childOfType(c, JTextArea.class) != null;
}


static int totalPreferredHeight(List<Component> l) {
  int h = 0;
  for (Component c : unnull(l))
    h += c.getPreferredSize().height;
  return h;
}


static <A> List<A> listWithoutIndicesInBitSet(List<A> l, BitSet bs) {
  List<A> out = new ArrayList();
  for (int i = 0; i < l(l); i++)
    if (!bs.get(i)) out.add(l.get(i));
  return out;
}


static double doubleRatio(double x, double y) {
  return y == 0 ? 0 : x/y;
}


static double doubleRatio(Seconds x, Seconds y) {
  return doubleRatio(x.get(), y.get());
}



static Dimension componentsBoundingSize(Container container, int insetBottomRight) {
  Rectangle r = new Rectangle(0, 0, 0, 0);
  for (Component c : container.getComponents())
    r = rectangleUnion(r, c.getBounds());
  return new Dimension(r.x+r.width+insetBottomRight, r.y+r.height+insetBottomRight);
}


static <A extends JLabel> A setHorizontalAlignment(final int pos, final A a) {
  swingCall(a, "setHorizontalAlignment", pos);
  return a;
}

static <A extends AbstractButton> A setHorizontalAlignment(final int pos, final A a) {
  swingCall(a, "setHorizontalAlignment", pos);
  return a;
}

static <A extends JTextField> A setHorizontalAlignment(final int pos, final A a) {
  swingCall(a, "setHorizontalAlignment", pos);
  return a;
}


static JTextArea jTextArea() {
  return jTextArea("");
}

static JTextArea jTextArea(final String text) {
  return jTextAreaWithUndo(text);
}


static <A> JComboBox<A> selectItem(A item, JComboBox<A> cb) {
  if (cb != null) { swing(() -> {  cb.setSelectedItem(item); }); }
  return cb;
}

static <A> JComboBox<A> selectItem(JComboBox<A> cb, A item) {
  return selectItem(item, cb);
}

static <A> JList<A> selectItem(JList<A> list, A item) {
  { swing(() -> {  selectRow(list, jlist_indexOf(list, item)); }); }
  return list;
}


static List<Integer> parseInts(Iterable<String> l) {
  return lambdaMap(__107 -> parseInt(__107), l);
}


static List<String> splitAtComma_trim(String s) {
  return nempties(trimAll(splitAtComma(s)));
}


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

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

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

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

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

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

static int jfind(List<String> tok, int startIdx, String in, Object condition) {
  //LS tokin = jfind_preprocess(javaTok(in));
  return jfind(tok, startIdx, javaTokForJFind_array(in), condition);
}

// assumes you preprocessed tokin
static int jfind(List<String> tok, List<String> tokin) {
  return jfind(tok, 1, tokin);
}

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

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

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

static 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 GrabbableIntPixels grabbableIntPixels_fastOrSlow(BufferedImage image) { try {
  try {
    GrabbableIntPixels gp = grabbableIntPixels(image);
    if (gp != null) return gp;
  } catch (Throwable __e) { pcallFail(__e); }
    
  // TODO: use GrabbableRGBBytePixels and convert manually
  // - should be way faster than PixelGrabber
  
  int w = image.getWidth(), h = image.getHeight();
  int[] data = new int[w*h];
  PixelGrabber pixelGrabber = new PixelGrabber(image, 0, 0, w, h, data, 0, w);
  if (!pixelGrabber.grabPixels())
    throw fail("Could not grab pixels");
      
  return new GrabbableIntPixels(data, w, h, 0, w);
} catch (Exception __e) { throw rethrow(__e); } }


static <A> List<A> listSetIntersection(Iterable<A> a, Collection<A> b) {
  List<A> l = new ArrayList();
  Set<A> bSet = asSet(b);
  for (A x : unnull(a)) if (bSet.contains(x)) l.add(x);
  return l;
}


static String autoFrameTitle_value;

static String autoFrameTitle() {
  return autoFrameTitle_value != null ? autoFrameTitle_value : getProgramTitle();
}

static void autoFrameTitle(Component c) {
  setFrameTitle(getFrame(c), autoFrameTitle());
}


static void fillTableWithStrings(final JTable table, List<List<String>> rows, List<String> colNames) {
  fillTableWithStrings(table, rows, toStringArray(colNames));
}

// thread-safe
static void fillTableWithStrings(final JTable table, List<List<String>> rows, String... colNames) {
  final DefaultTableModel model = fillTableWithStrings_makeModel(rows, colNames);
  
  swingNowOrLater(new Runnable() {  public void run() { try { 
    setTableModel(table, model);
  
} catch (Exception __e) { throw rethrow(__e); } }  public String toString() { return "setTableModel(table, model);"; }});
}

static DefaultTableModel fillTableWithStrings_makeModel(List<List<String>> rows, String... colNames) {
  Object[][] data = new Object[rows.size()][];
  int w = 0;
  for (int i = 0; i < rows.size(); i++) {
    List<String> l = rows.get(i);
    Object[] r = new Object[l.size()];
    for (int j = 0; j < l.size(); j++)
      r[j] = l.get(j);
    data[i] = r;
    w = Math.max(w, l.size());
  }
  Object[] columnNames = new Object[w];
  for (int i = 0; i < w; i++)
    columnNames[i] = i < l(colNames) ? colNames[i] : "?";
  return new DefaultTableModel(data, columnNames);
}



static <A> ThreadLocal<A> threadLocalWithDefault(A defaultValue) {
  return new ThreadLocal<A>() {
    public A initialValue() {
      return defaultValue;
    }
  };
}


static <A, B> List<A> keysWithoutHidden(Map<A, B> map) {
  return filter(keys(map) , new F1<Object, Boolean>() { public Boolean get(Object o) { try {  return !eq(o, "[hidden]") && !isStringStartingWith(o, "[hidden] ");  } catch (Exception __e) { throw rethrow(__e); } }
  public String toString() { return "!eq(o, \"[hidden]\") && !isStringStartingWith(o, \"[hidden] \")"; }});
}


static String structureOrText(Object o) {
  return o instanceof String ? (String) o : structure(o);
}


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




static IConceptIndex simpleConceptIndex(final Runnable r) {
  return new IConceptIndex() {
    public void update(Concept c) { pcallF(r); }
    public void remove(Concept c) { pcallF(r); }
  };
}


static Border jCompoundBorder(Border inner, Border outer) {
  if (inner == null) return outer;
  if (outer == null) return inner;
  return BorderFactory.createCompoundBorder(inner, outer);
}


static <A extends JComponent> A bindChangeListenerToComponent(A component, IHasChangeListeners hcl, Runnable listener) {
  return bindHasChangeListenersToComponent(component, hcl, listener);
}

static <A extends JComponent> A bindChangeListenerToComponent(IHasChangeListeners hcl, A component, Runnable listener) {
  return bindChangeListenerToComponent(component, hcl, listener);
}


static void setChecked(JCheckBox checkBox, boolean b) {
  if (checkBox != null) { swing(() -> { 
    if (isChecked(checkBox) != b)
      checkBox.setSelected(b);
  }); }
}

static void setChecked(JCheckBoxMenuItem mi, boolean b) {
  if (mi != null) { swing(() -> {  mi.setSelected(b); }); }
}


static boolean isInQ(Q q) {
  return q != null && isCurrentThread(q.rst.thread);
}


static <A, B> Either<A, B> eitherA(A a) {
  return new Either(1, a);
}


static <A, B> Either<A, B> eitherB(B b) {
  return new Either(2, b);
}


static <A> A returnOrThrow_either(Either<A, Throwable> e) {
  if (isEitherB(e)) throw rethrow(e.b());
  return eitherAOpt(e);
}


static <A> A waitForVarToBeNotNull(Var<A> v) { try {
  synchronized(v) {
    while (!v.has()) v.wait();
    return v.get();
  }
} catch (Exception __e) { throw rethrow(__e); } }
  


static boolean isIPv4(String s) {
  return s != null && l(javaTokC(s)) == 7 && jfind(javaTok(s), "<int>.<int>.<int>.<int>") == 1;
}


static boolean boolPar(ThreadLocal<Boolean> tl) {
  return boolOptParam(tl);
}



// defaults to false
static boolean boolPar(Object[] __, String name) {
  return boolOptParam(__, name);
}

static boolean boolPar(String name, Object[] __) {
  return boolOptParam(__, name);
}

static boolean boolPar(String name, Map __) {
  return boolOptParam(name, __);
}

static boolean boolPar(String name, Object[] params, boolean defaultValue) {
  return optParam(params, name, defaultValue);
}



static ThreadLocal<Long> saveTiming_last = new ThreadLocal();

static void saveTiming(long ms) {
  print(ms + " ms");
  saveTiming_noPrint(ms);
}

static void saveTiming_noPrint(long ms) {
  saveTiming_last.set(ms);
}

static ThreadLocal<Long> saveTiming_tl() {
  return saveTiming_last;
}


static TableWithTooltips tableWithToolTips() {
  return tableWithTooltips();
}



static List<String> getTableLine(JTable tbl, int row) {
  if (row >= 0 && row < tbl.getModel().getRowCount()) {
    List<String> l = new ArrayList();
    for (int i = 0; i < tbl.getModel().getColumnCount(); i++)
      l.add(String.valueOf(tbl.getModel().getValueAt(row, i)));
    return l;
  }
  return null;
}


static <A extends Image> A copyImageToClipboard(A img) {
  TransferableImage trans = new TransferableImage(img);
  Toolkit.getDefaultToolkit().getSystemClipboard().setContents( trans, null);
  vmBus_send("newClipboardContents", img);
  print("Copied image to clipboard (" + img.getWidth(null) + "*" + img.getHeight(null) + " px)");
  return img;
}



static JComponent showTitledForm(String title, Object... _parts) {
  return showFormTitled(title, _parts);
}



static void tableEnableDrag(final JTable table, TransferHandler th) {
  if (table.getDragEnabled()) {
    print("Table drag already enabled");
    return;
  }
  table.setDragEnabled(true);
  table.setTransferHandler(th);
  table.addMouseListener(new MouseAdapter() {
    @Override
    public void mousePressed(MouseEvent e) {
      if (e.getButton() == 1 && e.getClickCount() == 1)
        table.getTransferHandler().exportAsDrag(table, e, TransferHandler.COPY);
    }
  });
}


// this copies to RGBA
static 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;
}

// this one stays in color model. inconsistent i guess
static 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);
}


// TODO: does not detect set type (hash/tree) when it's synchronized
static <A> Set<A> cloneSet(Collection<A> set) {
  if (set == null) return new HashSet();
  synchronized(collectionMutex(set)) {
    Set<A> s = similarEmptySet(set);
    s.addAll(set);
    return s;
  }
}


// layouter: voidfunc(Container)
// or func(Container) -> Dimension [preferred size]
// or func(Container) -> Pair(Dimension, Dimension) [preferred, minimum]
static LayoutManager layoutManagerFromFunction(final Object layouter) {
  if (layouter instanceof LayoutManager) return ((LayoutManager) layouter);
  
  return new AbstractLayoutManager() {
    public void layoutContainer(Container parent) {
      Object size = pcallF(layouter, parent);
      if (size instanceof Dimension)
        preferredSize = (Dimension) size;
      else if (size instanceof Pair) {
        preferredSize = (Dimension) ((Pair) size).a;
        minimumSize = (Dimension) ((Pair) size).b;
      }
    }
  };
}


static <A extends Container> A addAllComponents(A c, List<? extends Component> components) {
  if (nempty(components)) { swing(() -> { 
    for (Component x : components)
      c.add(x);
    revalidate(c);
  }); }
  return c;
}

static <A extends Container> A addAllComponents(A c, Component... components) {
  return addAllComponents(c, asList(components));
}



static <A> A childOfType(Component c, Class<A> theClass) {
  return first(childrenOfType(c, theClass));
}

static <A> A childOfType(Class<A> theClass, Component c) {
  return childOfType(c, theClass);
}


static Rectangle rectangleUnion(Rectangle a, Rectangle b) {
  return a == null ? b : b == null ? a : a.union(b);
}


static JTextArea jTextAreaWithUndo() {
  return jTextAreaWithUndo("");
}

static JTextArea jTextAreaWithUndo(final String text) {
  return jenableUndoRedo(swingNu(JTextArea.class, text));
}


static void selectRow(final JTable table, final int i) {
  if (table != null) { swing(() -> { 
    if (i >= 0 && i < table.getRowCount()) {
      table.setRowSelectionInterval(i, i);
      scrollRowToVisible(table, i);
    } else
      table.clearSelection();
  }); }
}

static void selectRow(final JList list, final int i) {
  if (list != null) { swing(() -> { 
    if (i >= 0 && i < listRowCount(list))
      list.setSelectedIndex(i);
    else
      list.clearSelection();
  }); }
}


static <A> int jlist_indexOf(JList<A> list, A item) {
  return swing(new F0<Integer>() { public Integer get() { try { 
    ListModel<A> model = list.getModel();
    int n = model.getSize();
    for (int i = 0; i < n; i++)
      if (eq(model.getElementAt(i), item))
        return i;
    return -1;
   } catch (Exception __e) { throw rethrow(__e); } }
  public String toString() { return "ListModel<A> model = list.getModel();\r\n    int n = model.getSize();\r\n    for ..."; }});
}


static List<String> nempties(Collection<String> c) {
  return filterNempty(c);
}


static List<String> trimAll(String... l) {
  return trimAll(asList(l));
}

static List<String> trimAll(Collection<String> l) {
  List<String> l2 = new ArrayList();
  if (l != null) for (String s : l)
    l2.add(trim(s));
  return l2;
}


static List<String> splitAtComma(String s) {
  return empty(s) ? emptyList() : asList(s.split(","));
}


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






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


static 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 int findCodeTokens(List<String> tok, String... tokens) {
  return findCodeTokens(tok, 1, false, tokens);
}

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

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

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

static interface findCodeTokens_Matcher {
  boolean get(String token);
}

static int findCodeTokens(List<String> tok, int startIdx, boolean ignoreCase, String[] tokens, Object condition) {
  int end = tok.size()-tokens.length*2+2, nTokens = tokens.length;
  int i = startIdx | 1;

  findCodeTokens_Matcher[] matchers = new findCodeTokens_Matcher[nTokens];
  IContentsIndexedList2 indexedList = tok instanceof IContentsIndexedList2 ? (IContentsIndexedList2) tok : null;
  
  
  TreeSet<HasIndex> indices = null;
  int indicesOfs = 0;

  for (int j = 0; j < nTokens; j++) {
    String p = tokens[j];
    findCodeTokens_Matcher matcher;
    if (p.equals("*"))
      matcher = t -> true;
    else if (p.equals("<quoted>"))
      matcher = t -> isQuoted(t);
    else if (p.equals("<id>"))
      matcher = t -> isIdentifier(t);
    else if (p.equals("<int>"))
      matcher = t -> isInteger(t);
    else if (p.equals("\\*"))
      matcher = t -> t.equals("*");
    else if (ignoreCase)
      matcher = t -> eqic(p, t);
    else {
      matcher = t -> t.equals(p);
      if (indexedList != null) {
        TreeSet<HasIndex> indices2 = indexedList.indicesOf_treeSetOfHasIndex(p);
        
        if (indices2 == null) return -1;
        if (indices == null || indices2.size() < indices.size()) {
          // found shorter list
          indices = indices2;
          indicesOfs = j;
        }
      }
    }
    matchers[j] = matcher;
  }
  
  // go over shortest index
  if (indices != null) {
    int min = i+indicesOfs*2;
    SortedSet<HasIndex> tailSet = min == 1 ? indices : indices.tailSet(new HasIndex(min));
    
    outer: for (HasIndex h : tailSet) {
      int idx = h.idx-indicesOfs*2;
      if (idx >= end) break;
      
      for (int j = 0; j < nTokens; j++) try {
        if (!matchers[j].get(tok.get(idx+j*2)))
          continue outer;
      } catch (IndexOutOfBoundsException e) {
        print("fct indicesOfs=" + indicesOfs + ", h=" + h + ", idx=" + idx);
        throw e;
      }

      if (condition == null || checkTokCondition(condition, tok, idx-1))
        return idx;
    }
    return -1;
  }
 
  outer: for (; i < end; i += 2) {
    for (int j = 0; j < nTokens; j++)
      if (!matchers[j].get(tok.get(i+j*2)))
        continue outer;

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


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


// syntax 1: replace all occurrences of x in l with y
static <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;
}

// syntax 2: splice l at fromIndex-toIndex and replace middle part with y
static <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 Boolean grabbableIntPixels_succeeded;
static boolean grabbableIntPixels_enable = true;

static GrabbableIntPixels grabbableIntPixels(BufferedImage img) {
  if (img == null || !grabbableIntPixels_enable) return null;
  try {
    var result = grabbableIntPixels_impl(img);
    grabbableIntPixels_succeeded = result != null;
    return result;
  } catch (Throwable _e) {
    grabbableIntPixels_succeeded = false;
  
throw rethrow(_e); }
}

static GrabbableIntPixels grabbableIntPixels_impl(BufferedImage img) {
  Raster raster = img.getRaster();
  SampleModel _sampleModel = raster.getSampleModel();
  if (!(_sampleModel instanceof SinglePixelPackedSampleModel)) return null;
  SinglePixelPackedSampleModel sampleModel =  (SinglePixelPackedSampleModel) _sampleModel;
  DataBufferInt dataBuffer =  (DataBufferInt) (raster.getDataBuffer());
  assertEquals(1, dataBuffer.getNumBanks());
  assertEquals(DataBuffer.TYPE_INT, dataBuffer.getDataType());

  // Let's at this point assume the raster data is what we
  // think it is... (TODO: test on unusual platforms)
  
  int w = img.getWidth(), h = img.getHeight();
  int scanlineStride = sampleModel.getScanlineStride();
  int[] pixels = dataBuffer.getData();
  int offset = dataBuffer.getOffset();
  int translateX = raster.getSampleModelTranslateX();
  int translateY = raster.getSampleModelTranslateY();
  offset += -translateX-translateY*scanlineStride;
  return new GrabbableIntPixels(pixels, w, h, offset, scanlineStride);
}


static void swingNowOrLater(Runnable r) {
  if (isAWTThread())
    r.run();
  else
    swingLater(r);
}


static boolean isStringStartingWith(Object o, String prefix) {
  return o instanceof String && ((String) o).startsWith(prefix);
}


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




static boolean isCurrentThread(Thread t) {
  return t != null && t == currentThread();
}


static <A, B> boolean isEitherB(Either<A, B> e) {
  return eitherIsB(e);
}


static <A, B> A eitherAOpt(Either<A, B> e) {
  return e != null && e.isA() ? e.a() : null;
}


static TableWithTooltips tableWithTooltips() {
  return (TableWithTooltips) swing(new F0<Object>() { public Object get() { try {  return new TableWithTooltips();  } catch (Exception __e) { throw rethrow(__e); } }
  public String toString() { return "return new TableWithTooltips;"; }});
}

static class TableWithTooltips extends JTable {
  public String getToolTipText(MouseEvent e) {
    String tip = null;
    Point p = e.getPoint();
    int rowIndex = rowAtPoint(p);
    int colIndex = columnAtPoint(p);

    try {
      return str(getValueAt(rowIndex, colIndex));
    } catch (Throwable _e) {
      return null;
    }
  }
}


// undefined color, seems to be all black in practice
// This is without alpha?
static BufferedImage newBufferedImage(int w, int h) {
  return new BufferedImage(w, h, BufferedImage.TYPE_INT_RGB);
}


static BufferedImage newBufferedImage(int w, int h, RGB rgb) {
  return newBufferedImage(w, h, rgb.getColor());
}


static 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 BufferedImage newBufferedImage(Pt p, Color color) {
  return newBufferedImage(p.x, p.y, color);
}



static BufferedImage newBufferedImage(WidthAndHeight size, Color color) {
  return newBufferedImage(size.w(), size.h(), color);
}


// This one is with alpha...
static BufferedImage newBufferedImage(int w, int h, int[] pixels) {
  return intArrayToBufferedImage(pixels, w, h);
}


// changes & returns canvas
static BufferedImage drawImage(BufferedImage canvas, Image img, Pt p) {
  return drawImageOnImage(img, canvas, p.x, p.y);
}

static void drawImage(BufferedImage g, Image img) { drawImage(graphics(g), img); }

static void drawImage(Graphics2D g, Image img) {
  drawImage(g, img, 0, 0);
}

static void drawImage(Graphics2D g, Image img, Pt p) {
  drawImage(g, img, p.x, p.y);
}

static void drawImage(Graphics2D g, Image img, int x, int y) {
  { if (g != null) g.drawImage(img, x, y, null); }
}


static void scrollRowToVisible(JTable t, int rowIndex) {
  int colIndex = 0;
  if (!(t.getParent() instanceof JViewport))
    return;
  
  JViewport viewport = (JViewport) t.getParent();
  Rectangle rect = t.getCellRect(rowIndex, colIndex, true);
  Rectangle viewRect = viewport.getViewRect();

  int x = viewRect.x;
  int y = viewRect.y;

  if (rect.x >= viewRect.x && rect.x <= (viewRect.x + viewRect.width - rect.width)){

  } else if (rect.x < viewRect.x){
      x = rect.x;
  } else if (rect.x > (viewRect.x + viewRect.width - rect.width)) {
      x = rect.x - viewRect.width + rect.width;
  }

  if (rect.y >= viewRect.y && rect.y <= (viewRect.y + viewRect.height - rect.height)){

  } else if (rect.y < viewRect.y){
      y = rect.y;
  } else if (rect.y > (viewRect.y + viewRect.height - rect.height)){
      y = rect.y - viewRect.height + rect.height;
  }

  viewport.setViewPosition(new Point(x,y));
}


static int listRowCount(JList list) {
  return list == null ? 0 : swing(new F0<Integer>() { public Integer get() { try {  return list.getModel().getSize();  } catch (Exception __e) { throw rethrow(__e); } }
  public String toString() { return "return list.getModel().getSize();"; }});
}


static 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 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 <A> int indexOfSubList(List<A> x, List<A> y) {
  return indexOfSubList(x, y, 0);
}

static <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 <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 <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 List<String> javaTokForStructure(String s) {
  return javaTok_noMLS(s);
}


static String structure_addTokenMarkers(String s) {
  return join(structure_addTokenMarkers(javaTokForStructure(s)));
}
  
static List<String> structure_addTokenMarkers(List<String> tok) {
  // find references
  
  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;
  
  // add markers
  for (int i : refs) {
    int idx = i*2+1;
    if (idx >= l(tok)) continue; // broken structure
    String t = "";
    if (endsWithLetterOrDigit(tok.get(idx-1))) t = " ";
    tok.set(idx, t + "m" + i + " " + tok.get(idx));
  }
  
  return tok;
}




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

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

// leaves tok properly tokenized
// returns true iff anything was replaced
static boolean jreplace(List<String> tok, String in, String out) {
  return jreplace(tok, in, out, false, true, null);
}

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

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

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

static 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++) { // TODO: don't need this check anymore
    i = findCodeTokens(tok, i+1, ignoreCase, toks, condition);
    if (i < 0)
      return anyChange;
    List<String> subList = tok.subList(i-1, i+lTokin-1); // N to N
    String expansion = jreplaceExpandRefs(out, subList);
    int end = i+lTokin-2;
    
    clearAllTokens(tok, i, end); // C to C
    tok.set(i, expansion);
    if (reTok) // would this ever be false??
      reTok(tok, i, end);
    i = end;
    anyChange = true;
  }
  throw fail("woot? 10000! " + quote(in) + " => " + quote(out));
}

static boolean jreplace_debug = false;




static <A, B> boolean eitherIsB(Either<A, B> e) {
  return e != null && e.isB();
}


// from: https://stackoverflow.com/questions/14416107/int-array-to-bufferedimage
// pixels are RGB pixels
static BufferedImageWithMeta intArrayToBufferedImage(int[] pixels, int w) { return intArrayToBufferedImage(pixels, w, pixels.length/w); }
static BufferedImageWithMeta intArrayToBufferedImage(int[] pixels, int w, int h) {
  if (w == 0 || h == 0) return null;
  
  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 BufferedImageWithMeta intArrayToBufferedImage(int w, int... pixels) {
  return intArrayToBufferedImage(pixels, w);
}


// changes & returns canvas
static BufferedImage drawImageOnImage(Image img, BufferedImage canvas, int x, int y) {
  createGraphics(canvas).drawImage(img, x, y, null);
  return canvas;
}

static BufferedImage drawImageOnImage(Image img, BufferedImage canvas) {
  return drawImageOnImage(img, canvas, 0, 0);
}





static Graphics2D graphics(BufferedImage img) {
  return imageGraphics(img);
}


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

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


static 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;
    
    // scan for whitespace
    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);

    // scan for non-whitespace
    
    if (c == '\'' || c == '"') {
      char opener = c;
      ++j;
      while (j < l) {
        int c2 = s.charAt(j);
        if (c2 == opener || c2 == '\n' && opener == '\'') { // allow multi-line strings, but not for '
          ++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; // Long constants like 1L
    } else
      ++j;
      
    tok.add(javaTok_substringC(s, i, j));
    ++n;
    i = j;
  }
  
  if ((tok.size() % 2) == 0) tok.add("");
  return tok;
}


// "$1" is first code token, "$2" second code token etc.
static 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 void clearAllTokens(List<String> tok) {
    for (int i = 0; i < tok.size(); i++)
      tok.set(i, "");
  }
  
  static void clearAllTokens(List<String> tok, int i, int j) {
    for (; i < j; i++)
      tok.set(i, "");
  }


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

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

static List<String> reTok(List<String> tok, int i, int j) {
  // extend i to an "N" token
  // and j to "C" (so j-1 is an "N" token)
  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);
  
  // fallback to safety
  // reTok(tok);
  
  return tok;
}






static Map<BufferedImage, Object> createGraphics_modulators = synchroIdentityHashMap();

static Graphics2D createGraphics(BufferedImage img) {
  Graphics2D g = img.createGraphics();
  Object mod = createGraphics_modulators.get(img);
  if (mod != null)
    callF(mod, g);
  return g;
}

// mod: voidfunc(Graphics2D)
static void createGraphics_modulate(BufferedImage img, Object mod) {
  mapPut2(createGraphics_modulators, img, mod);
}


static ThreadLocal<Boolean> imageGraphics_antiAlias = new ThreadLocal();

static Graphics2D imageGraphics(BufferedImage img) {
  return !isFalse(imageGraphics_antiAlias.get()) ? antiAliasGraphics(img) : createGraphics(img);
}


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


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




static <A, B> Map<A, B> synchroIdentityHashMap() {
  return synchroMap(new IdentityHashMap());
}


static <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 Graphics2D antiAliasGraphics(BufferedImage img) {
  return antiAliasOn(createGraphics(img));
}




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




interface IVarWithNotify<A> extends IVar<A>, IF0WithChangeListeners<A> {
  default IVarWithNotify<A> onChange(IVF1<A> r) {
    if (r == null) return this;
    onChange(() -> r.get(get()));
    return this;
  }
  
  default IVarWithNotify<A> onChangeAndNow(IVF1<A> r) {
    if (r == null) return this;
    onChangeAndNow(() -> r.get(get()));
    return this;
  }
}
// TODO: improve filtering

static class AutoComboBox extends JComboBox<String> {
  String keyWord[];
  Vector myVector = new Vector();
  boolean acceptOnTab = false; // don't work so good
  
  AutoComboBox() {
    setModel(new DefaultComboBoxModel(myVector));
    setSelectedIndex(-1);
    setEditable(true);
    JTextField text = (JTextField) this.getEditor().getEditorComponent();
    text.setFocusable(true);
    text.setText("");
    text.addKeyListener(new ComboListener(this, myVector));
    if (acceptOnTab) text.setFocusTraversalKeysEnabled(false);
    setMyVector();
  }
  
  /**
   * set the item list of the AutoComboBox
   * @param keyWord an String array
   */
  void setKeyWord(String[] keyWord) {
    this.keyWord = keyWord;
    setMyVector();
  }
  
  void setKeyWord(Collection<String> keyWord) {
    setKeyWord(toStringArray(keyWord));
  }
  
  private void setMyVector() {
    copyArrayToVector(keyWord, myVector);
  }
  
  class ComboListener extends KeyAdapter {
    JComboBox cb;
    Vector vector;
    
    ComboListener(JComboBox cb, Vector vector) {
  this.vector = vector;
  this.cb = cb;}
    
    public void /*keyReleased*/keyPressed(KeyEvent key) {
      if (key.getKeyCode() == KeyEvent.VK_ENTER) return;
      
      if (key.getKeyCode() == KeyEvent.VK_ESCAPE) { cb.hidePopup(); return; }
      
      if (acceptOnTab && key.getKeyCode() == KeyEvent.VK_TAB /*&& key.getModifiers() == 0*/) {
        _print("Have tab event (modifiers=" + key.getModifiers() + ")");
        if ((key.getModifiers() & ActionEvent.SHIFT_MASK) == 0 && cb.isPopupVisible()) {
          cb.setSelectedIndex(0); // accept item
          cb.hidePopup();
        } else // standard tab behavior
          swing_standardTabBehavior(key);
          
        return;
      }
      
      JTextField tf =  (JTextField) (cb.getEditor().getEditorComponent());
      
      if (tf.getCaretPosition() != l(tf.getText())) return;
      
      String text = ((JTextField) key.getSource()).getText();
  
      Vector list = getFilteredList(text);
      if (nempty(list)) {
        cb.setModel(new DefaultComboBoxModel(list));
        cb.setSelectedIndex(-1);
        tf.setText(text); // necessary?
        cb.showPopup();
      } else
        cb.hidePopup();
    }
  
    public Vector getFilteredList(String text) {
      return emptyAfterTrim(text) ? vector : new Vector(scoredSearch(text, vector));
    }
  }
}
abstract static class AbstractLayoutManager implements LayoutManager {
   final public AbstractLayoutManager setPreferredSize(Dimension preferredSize){ return preferredSize(preferredSize); }
public AbstractLayoutManager preferredSize(Dimension preferredSize) { this.preferredSize = preferredSize; return this; }  final public Dimension getPreferredSize(){ return preferredSize(); }
public Dimension preferredSize() { return preferredSize; }
 Dimension preferredSize = new Dimension(100, 100);
   final public AbstractLayoutManager setMinimumSize(Dimension minimumSize){ return minimumSize(minimumSize); }
public AbstractLayoutManager minimumSize(Dimension minimumSize) { this.minimumSize = minimumSize; return this; }  final public Dimension getMinimumSize(){ return minimumSize(); }
public Dimension minimumSize() { return minimumSize; }
 Dimension minimumSize = new Dimension(10, 10);

  public void addLayoutComponent(String name, Component comp) {}
  public void removeLayoutComponent(Component comp) {}
  
  AbstractLayoutManager preferredSize(int w, int h) {
    return preferredSize(new Dimension(w, h));
  }
  
  public Dimension preferredLayoutSize(Container parent) {
    layoutContainer(parent);
    //print("preferredSize: " + preferredSize + " (parent size: " + jGetSize(parent) + ")");
    return preferredSize;
  }
  
  public Dimension minimumLayoutSize(Container parent) {
    //print("minimumLayoutSize");
    return minimumSize;
  }
}
static class BufferedImageWithMeta extends BufferedImage implements IMeta {
  BufferedImageWithMeta(ColorModel cm,
    WritableRaster raster,
    boolean isRasterPremultiplied,
    Hashtable<?,?> properties) {
    super(cm, raster, isRasterPremultiplied, properties);
  }

  
// Meta - a "minimal" approach to adding meta-level to Java objects
// (implementing the interface IMeta)

// We allocate one extra field for each Java object to make it
// reasoning-compatible (reasoning-compatible = extensible with
// fields of any name at runtime).
//
// We couldn't go for 0 extra fields (meta values must be linked
// directly from the object) and there are no half fields in
// Java... so there you go.
//
// Also, if you don't use any meta data, you are probably not
// reasoning about anything. The point of reasoning in JavaX is
// to attach information to objects directly used in the program.

// Possible information contained in the meta field:
//   Origin, destination, security level, sender, cost center,
//   purpose, list of reifications, ...

// So here it is. THE FIELD YOU HAVE BEEN WAITING FOR!

// [We also have IMeta to retrofit foreign classes (rare but
// probably useful).]

//////////////////////
// The "meta" field //
//////////////////////

// Generic meta value of any kind, but the typical case is it's a
// Map with extra field values for the object etc.
// "meta" is volatile to avoid synchronization; but you can also synchronize on
// _tempMetaMutex() which is usually the object itself. Collections
// and maps are exempt from using the collections's monitor as the meta
// mutex because their monitor tends to be held for long operations
// (e.g. cloneList). For those we use a substantially more complex
// algorithm using a weakMap. Probably overkill. I may reconsider.

volatile Object meta;

// The meta field is not transient, thus by default it will be
// persisted like anything else unless you customize your object
// to suppress or modulate this.

// ...and the interface methods

public void _setMeta(Object meta) { this.meta = meta; }
public Object _getMeta() { return meta; }

// MOST functions are implemented in IMeta (default implementations)

// Scaffolding convenience functions

final boolean scaffolding(){ return scaffoldingEnabled(); }
final boolean scaffolded(){ return scaffoldingEnabled(); }
boolean scaffoldingEnabled() { return main.scaffoldingEnabled(this); }
boolean scaffoldingEnabled(Object o) { return main.scaffoldingEnabled(o); }

// Implementing setMetaToString

String toString_base() { return super.toString(); }
public String toString() {
  Object o = metaGet("toString", this);
  if (o instanceof String) return ((String) o);
  if (o instanceof IF1) return str(((IF1) o).get(this));
  return toString_base();
}
}
static ThreadLocal<Map<String, String>> MyHTTPD_headers = new ThreadLocal();
static ThreadLocal<MyHTTPD> MyHTTPD_current = new ThreadLocal();

static class MyHTTPD extends NanoHTTPD {
  MyHTTPD(int port) { super(port); }
  
  Object onServe, onEndServe;
  volatile long requests;
  transient IF0<AutoCloseable> enter;
  
  Object serveFunction = new F2<String, Map<String, String>, Object>() { public Object get(String uri, Map<String, String> parms) { try { 
    return callHtmlMethod2(getMainClass(), uri, parms);
   } catch (Exception __e) { throw rethrow(__e); } }
  public String toString() { return "callHtmlMethod2(getMainClass(), uri, parms)"; }};
  
  static class Serving {
    String uri;
    Map<String, String> header, parms, files;
  }
  
  Set<Serving> currentlyServing = synchroSet();

  public Response serve(String uri, Method method,
    Map<String, String> header, Map<String, String> parms, Map<String, String> files) { try {
     AutoCloseable __1 = callF(enter); try {
    ++requests;
     AutoCloseable __2 = tempSetThreadLocal(MyHTTPD_current, this); try {
    Serving serving = nu(Serving.class, "uri", uri, "header", header, "parms", parms, "files", files);
    currentlyServing.add(serving);
    pcallF(onServe, serving);
    try {
      String remoteAddr = getClientIPFromHeaders(header);
      String host = header.get("host");
      print(formatDateAndTime() + " Serving URI: " + quote((nempty(host) ? "//" + host : "") + uri) + " to: " + remoteAddr);
      
      /*if (nempty(remoteAddr) &&
        isTrue(callOpt(mc(), "isBlockedIP", remoteAddr))) {
        print("BLOCKED IP.");
        ret serve404();
      }*/
      
      try {
        Response response =  (Response) (callOpt(getMainClass(), "serve", uri, method, header, parms, files));
        if (response != null) return response;
        Object html;
        MyHTTPD_headers.set(header);
        try {
          html = callF(serveFunction, uri, parms);
        } finally {
          MyHTTPD_headers.set(null);
        }
        
        if (html != null)
          return html instanceof String ? serveHTML((String) html) : (NanoHTTPD.Response) html;
        return serve404();
      } catch (Throwable e) {
        printStackTrace(e);
        return serveHTML("ERROR.");
      }
    } finally {
      pcallF(onEndServe, serving);
      currentlyServing.remove(serving);
    }
  } finally { _close(__2); }} finally { _close(__1); }} catch (Exception __e) { throw rethrow(__e); } }
}
static interface ITokCondition {
  boolean get(List<String> tok, int i); // i = N Index
}
static abstract class TokCondition implements ITokCondition {
  public abstract boolean get(List<String> tok, int i); // i = N Index
}
static class RightAlignedLine extends JPanel {
  RightAlignedLine(int spacing, Component... components) {
    this(components);
    setSpacing(spacing);
  }
    
  RightAlignedLine(Component... components) {
    setLayout(LetterLayout.rightAlignedRow());
    for (Component component : components)
      if (component != null)
        add(component);
  }
  
  void setSpacing(int spacing) {
    ((LetterLayout) getLayout()).setSpacing(spacing, spacing);
  }

  public void add(String text) {
    add(new JLabel(text));
  }
}
static interface MakesBufferedImage extends WidthAndHeight {
  BufferedImage getBufferedImage();
  
  public default void drawAt(Graphics2D g, int x, int y) {
    g.drawImage(getBufferedImage(), x, y, null);
  }
  
  
    default int getWidth() { return getBufferedImage().getWidth(); }
  

    default int getHeight() { return getBufferedImage().getHeight(); }
  

}
// optimized for search - O(1) for searching for a certain element
// set is O(log m) with m = number of occurrences of element
final static class ContentsIndexedList<A> extends RandomAccessAbstractList<A> implements IContentsIndexedList<A>, IContentsIndexedList2<A> {
  Map<A, TreeSet<Elem<A>>> index = new HashMap(); // tokens by contents, sorted by index
  final ArrayList<Elem<A>> list = new ArrayList();

  final static class Elem<A> extends HasIndex {
    A s; // actual token
    
    public String toString() { return "Elem " + quote(s) + "@" + idx; }
  }
  
  ContentsIndexedList() {}
  ContentsIndexedList(Map<A, TreeSet<Elem<A>>> index) {
  this.index = index;} // use different type of index (e.g. ciMap)
  ContentsIndexedList(Collection<A> l) { addAll(l); }
  
  public A get(int i) { return list.get(i).s; }
  public int size() { return list.size(); }
  
  public A set(int i, A s) {
    Elem<A> t = list.get(i);
    A old = t.s;
    if (eq(old, s)) return old;
    removeFromIdx(t);
    t.s = s;
    addToIdx(t);
    return old;
  }
  
  public boolean add(A s) {
    ++modCount;
    Elem<A> t = new Elem();
    t.s = s;
    t.idx = size();
    list.add(t);
    addToIdx(t);
    return true;
  }
  
  public void add(int i, A s) {
    ++modCount;
    Elem<A> t = new Elem();
    t.s = s;
    t.idx = i;
    list.add(i, t);
    reorder(i+1);
    addToIdx(t);
  }
  
  public boolean addAll(int i, Collection<? extends A> l) {
    int n = l.size();
    if (n == 0) return false;
    ++modCount;
    List<Elem<A>> l2 = emptyList(n);
    int j = i;
    for (A s : l) {
      Elem<A> t = new Elem();
      t.s = s;
      t.idx = j++;
      l2.add(t);
    }
    list.addAll(i, l2);
    reorder(i+n);
    for (Elem<A> t : l2)
      addToIdx(t);
    return true;
  }
  
  public A remove(int i) {
    ++modCount;
    Elem<A> t = list.get(i);
    removeFromIdx(t);
    list.remove(i);
    reorder(i);
    return t.s;
  }
  
  void reorder(int fromIdx) {
    int n = size();
    for (int i = fromIdx; i < n; i++)
      list.get(i).idx = i;
  }
  
  void removeFromIdx(Elem<A> t) {
    TreeSet<Elem<A>> idx = index.get(t.s);
    idx.remove(t);
    if (idx.isEmpty()) index.remove(t.s);
  }
  
  void addToIdx(Elem<A> t) {
    TreeSet<Elem<A>> idx = index.get(t.s);
    if (idx == null)
      index.put(t.s, idx = new TreeSet());
    idx.add(t);
  }
  
  @Override
  public int indexOf(Object s) {
    TreeSet<Elem<A>> l = index.get(s);
    return l == null ? -1 : first(l).idx;
  }
  
  @Override
  public int lastIndexOf(Object s) {
    TreeSet<Elem<A>> l = index.get(s);
    return l == null ? -1 : last(l).idx;
  }
  
  @Override
  public boolean contains(Object s) {
    return index.containsKey(s);
  }
  
  public void clear() {
    ++modCount;
    index.clear();
    list.clear();
  }
  
  protected void removeRange(int fromIndex, int toIndex) {
    if (fromIndex == toIndex) return;
    ++modCount;
    
    for (int i = fromIndex; i < toIndex; i++)
      removeFromIdx(list.get(i));
      
    list.subList(fromIndex, toIndex).clear();
    reorder(fromIndex);
  }
  
  public int[] indicesOf(A o) {
    TreeSet<Elem<A>> idx = index.get(o);
    if (idx == null) return emptyIntArray();
    int[] a = new int[idx.size()];
    int i = 0;
    for (Elem<A> t : idx) a[i++] = t.idx;
    return a;
  }
  
  public TreeSet<HasIndex> indicesOf_treeSetOfHasIndex(A o) {
    return (TreeSet) index.get(o);
  }
}
static class GrabbableIntPixels implements IFieldsToList{
  static final String _fieldOrder = "data w h offset scanlineStride";
  int[] data;
  int w;
  int h;
  int offset;
  int scanlineStride;
  GrabbableIntPixels() {}
  GrabbableIntPixels(int[] data, int w, int h, int offset, int scanlineStride) {
  this.scanlineStride = scanlineStride;
  this.offset = offset;
  this.h = h;
  this.w = w;
  this.data = data;}
  public String toString() { return shortClassName_dropNumberPrefix(this) + "(" + data + ", " + w + ", " + h + ", " + offset + ", " + scanlineStride + ")"; }

public boolean equals(Object o) {
if (!(o instanceof GrabbableIntPixels)) return false;
    GrabbableIntPixels __1 =  (GrabbableIntPixels) o;
    return eq(data, __1.data) && w == __1.w && h == __1.h && offset == __1.offset && scanlineStride == __1.scanlineStride;
}

  public int hashCode() {
    int h = -1183022196;
    h = boostHashCombine(h, _hashCode(data));
    h = boostHashCombine(h, _hashCode(w));
    h = boostHashCombine(h, _hashCode(h));
    h = boostHashCombine(h, _hashCode(offset));
    h = boostHashCombine(h, _hashCode(scanlineStride));
    return h;
  }
  public Object[] _fieldsToList() { return new Object[] {data, w, h, offset, scanlineStride}; }

  int[] asPackedArray() {
    if (offset == 0 && data.length == w*h) return data;
    int[] pixels = new int[w*h];
    for (int y = 0; y < h; y++)
      arrayCopy(data, offset+y*scanlineStride, pixels, y*h, w);
    return pixels;
  }
}




static class TransferableImage implements Transferable {
  Image i;

  TransferableImage(Image i) {
  this.i = i;}

  public Object getTransferData( DataFlavor flavor )
  throws UnsupportedFlavorException, IOException {
      if ( flavor.equals( DataFlavor.imageFlavor ) && i != null ) {
          return i;
      }
      else {
          throw new UnsupportedFlavorException( flavor );
      }
  }

  public DataFlavor[] getTransferDataFlavors() {
      DataFlavor[] flavors = new DataFlavor[ 1 ];
      flavors[ 0 ] = DataFlavor.imageFlavor;
      return flavors;
  }

  public boolean isDataFlavorSupported( DataFlavor flavor ) {
      DataFlavor[] flavors = getTransferDataFlavors();
      for ( int i = 0; i < flavors.length; i++ ) {
          if ( flavor.equals( flavors[ i ] ) ) {
              return true;
          }
      }

      return false;
  }
}
static class SimpleLiveValue<A> extends LiveValue<A> implements IVarWithNotify<A> {
   transient 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); }
  Class<A> type;
  volatile A value;
  
  SimpleLiveValue(Class<A> type) {
  this.type = type;}
  SimpleLiveValue(Class<A> type, A value) {
  this.value = value;
  this.type = type;}
  
  public Class<A> getType() { return type; }
  public A get() { return value; }

  void fireChanged() { change(); }
  public void set(A a) { if (neq(value, a)) { value = a; fireChanged(); } }
}
static interface IContentsIndexedList2<A> extends List<A> {
  TreeSet<HasIndex> indicesOf_treeSetOfHasIndex(A o);
}
static class PNGFile extends Concept {
  String pngPath; // program ID + "/" + file name
  Rect r; // optional, rectangle that was shot
  
  PNGFile() {} // for persistance
  PNGFile(String pngPath) {
  this.pngPath = pngPath;}
  
    PNGFile(RGBImage img) { this(img.getBufferedImage()); }
  

  File pngFile() {
    if (pngPath == null) {
      pngPath = _programID() + "/" + id + ".png";
      change();
    }
    return prepareFile(new File(javaxDataDir(), pngPath));
  }
  
  
  PNGFile(BufferedImage img) {
    savePNG(pngFile(), img);
  }
  BufferedImage loadImage() { return loadImage2(pngFile()); }
  BufferedImage getImage() { return loadImage(); }
  BufferedImage getImageSafe() { try { return loadImage(); } catch (Throwable __e) { pcallFail(__e); } return null; }
  String md5() { try { return md5OfBufferedImage(getImage()); } catch (Throwable __e) { pcallFail(__e); } return "-"; }
  
  
  boolean hasImage() {
    return pngFile().exists();
  }
}

static class ExpiringMap2<A, B> extends AbstractMap<A, B> {
  Map<A, Pair<Long, B>> byKey = new HashMap();      // key -> pair(expiry sys time, value)
  PriorityBlockingQueue<Pair<Long, A>> queue = new PriorityBlockingQueue(); // queue(pair(expiry sys time, key))
  long standardExpiryTime; // ms
  boolean renewOnOverwrite = true, renewOnGet;
  Object onChange;
  boolean useCountdown = true;
  RestartableCountdown countdown = new RestartableCountdown();

  ExpiringMap2() {}
  ExpiringMap2(long standardExpiryTime) {
  this.standardExpiryTime = standardExpiryTime;}
  ExpiringMap2(long standardExpiryTime, Object onChange) {
  this.onChange = onChange;
  this.standardExpiryTime = standardExpiryTime;}
  ExpiringMap2(double standardExpirySeconds) { standardExpiryTime = toMS(standardExpirySeconds); }
  
  synchronized boolean clean() {
    boolean changes = false;
    Pair<Long, A> p;
    long time = sysTime();
    while ((p = queue.peek()) != null && time >= p.a) {
      if (useCountdown) countdown.stop();
      
      p = queue.poll();
      
      Pair<Long, B> v = byKey.get(p.b);
      if (v != null /*&& v.a == p.a*/) {
        
        byKey.remove(p.b);
        changes = true;
        change();
      }
    }
    if (useCountdown) 
      countdown.setTargetTime(p != null ? p.a : 0, new Runnable() {  public void run() { try {  clean(); 
} catch (Exception __e) { throw rethrow(__e); } }  public String toString() { return "clean();"; }});
    return changes;
  }
  
  void change() { callF(onChange); }
  
  synchronized public B put(A a, B b) {
    clean();
    long timeout = sysTime()+standardExpiryTime;
    Pair<Long, B> p = byKey.get(a);
    if (p != null && renewOnOverwrite)
      queue.remove(new Pair(p.a, a));
    byKey.put(a, pair(timeout, b));
    change();
    if (p == null || renewOnOverwrite)
      queue.add(new Pair(timeout, a));
    return pairB(p);
  }
  
  synchronized public B remove(Object a) {
    clean();
    Pair<Long, B> p = byKey.get(a);
    if (p == null) return null;
    queue.remove(new Pair(p.a, a));
    byKey.remove(a);
    change();
    return p.b;
  }
  
  synchronized public B get(Object a) {
    clean();
    Pair<Long, B> p = byKey.get(a);
    if (renewOnGet && p != null) {
      queue.remove(new Pair(p.a, a));
      long timeout = sysTime()+standardExpiryTime;
      byKey.put((A) a, pair(timeout, p.b));
      queue.add(new Pair(timeout, a));
    }
    return pairB(p);
  }
  
  synchronized public Set<Map.Entry<A,B>> entrySet() {
    clean();
    // TODO: mutex
    return synchronizedSet(mapValues(__116 -> pairB(__116), byKey).entrySet());
  }
  
  synchronized public Set<A> keySet() {
    clean();
    return synchronizedSet(byKey.keySet());
  }
  
  synchronized public int size() {
    clean();
    return byKey.size();
  }
  
  void setStandardExpiryTime(long ms) { standardExpiryTime = ms; }
  
  synchronized ExpiringMap2<A, B> setMap(Map innerMap) {
    byKey = innerMap;
    return this;
  }
}
/*
 * The Alphanum Algorithm is an improved sorting algorithm for strings
 * containing numbers.  Instead of sorting numbers in ASCII order like
 * a standard sort, this algorithm sorts numbers in numeric order.
 *
 * The Alphanum Algorithm is discussed at http://www.DaveKoelle.com
 *
 * Released under the MIT License - https://opensource.org/licenses/MIT
 *
 * Copyright 2007-2017 David Koelle
 *
 * Permission is hereby granted, free of charge, to any person obtaining
 * a copy of this software and associated documentation files (the "Software"),
 * to deal in the Software without restriction, including without limitation
 * the rights to use, copy, modify, merge, publish, distribute, sublicense,
 * and/or sell copies of the Software, and to permit persons to whom the
 * Software is furnished to do so, subject to the following conditions:
 *
 * The above copyright notice and this permission notice shall be included
 * in all copies or substantial portions of the Software.
 *
 * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
 * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
 * MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.
 * IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM,
 * DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR
 * OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE
 * USE OR OTHER DEALINGS IN THE SOFTWARE.
 */

/**
 * This is an updated version with enhancements made by Daniel Migowski,
 * Andre Bogus, and David Koelle. Updated by David Koelle in 2017.
 */
 
static class AlphanumComparator implements Comparator<String> {
  boolean ignoreCase = false;
  
  private final boolean isDigit(char ch) {
    return ((ch >= 48) && (ch <= 57));
  }

  /** Length of string is passed in for improved efficiency (only need to calculate it once) **/
  private final 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();

      // If both chunks contain numeric characters, sort them numerically
      int result = 0;
      if (isDigit(thisChunk.charAt(0)) && isDigit(thatChunk.charAt(0)))
      {
          // Simple chunk comparison by length.
          int thisChunkLength = thisChunk.length();
          result = thisChunkLength - thatChunk.length();
          // If equal, the first different number counts
          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 class Value<A> implements IF0<A> , IFieldsToList{
  A value;
  Value() {}
  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 class Either<A, B> {
  byte which;
  Object value;
  
  Either() {}
  Either(int which, Object value) { this.which = (byte) which;
  this.value = value; }
  
  boolean isA() { return which == 1; }
  boolean isB() { return which == 2; }
  
  A a() { if (which != 1) _failMe(); return (A) value; }
  B b() { if (which != 2) _failMe(); return (B) value; }
  
  A aOpt() { return which != 1 ? null : (A) value; }
  B bOpt() { return which != 2 ? null : (B) value; }
  
  void _failMe() {
    throw fail("Either object is of wrong type: " + shortClassName(value));
  }
  
  public String toString() {
    return "Either" + (isA() ? "A" : "B") + "(" + value + ")";
  }
}
static interface IIntPred {
  boolean get(int a);
}
static class HasIndex implements Comparable<HasIndex> {
  int idx;
  
  HasIndex() {}
  HasIndex(int idx) {
  this.idx = idx;}
  
  public int compareTo(HasIndex h) {
    return idx-h.idx;
  }
  
  final int get() { return idx; }
}


abstract static class RandomAccessAbstractList<A> extends AbstractList<A> implements RandomAccess {
}
static interface IContentsIndexedList<A> extends List<A> {
  int[] indicesOf(A o);
}
static class LetterLayout implements LayoutManager {
  private String[] lines;
  private Map<String, Component> map = new TreeMap();
  private Map<Component, String> constraints = new HashMap();
  private RC[] rows;
  private RC[] cols;
  private Cell[][] cells;
  private int spacingX = 10, spacingY = 10;
  private int insetTop, insetBottom, insetLeft, insetRight;
  private int template;
  private boolean formWideLeftSide, formWideRightSide;

  private static final int STALACTITE = 1, LEFT_ALIGNED_ROW = 2, CENTERED_ROW = 3, FORM = 4, RIGHT_ALIGNED_ROW = 5;
  private 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 class DummyComponent extends JComponent {
  }

  /**
   * info about one matrix cell
   */
  static class Cell {
    boolean aux = false; // part of a larger cell, but not top-left corner
    int minWidth, minHeight;
    Component component;
    int colspan, rowspan;
    double weightX, weightY;
  }

  /**
   * info about one matrix row / column
   */
  static class RC {
    int min;
    double weightSum;
    int start;
    int minEnd;
  }

  private LetterLayout(int template) {
    this.template = template;
  }

  public LetterLayout(String... lines) {
    this.lines = lines;
  }

  public void layoutContainer(Container container) {
    prepareLayout(container);

    // do layout

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

  private 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();

    // define cells

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

    // determine minStarts, weightSums

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

    // determine row, col starts

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

  private boolean allWeightsZero(RC[] rcs) {
    for (int i = 0; i < rcs.length; i++)
      if (rcs[i].weightSum != 0.0)
        return false;
    return true;
  }

  private static int getMinimumHeight(Component c) {
    /*if (c instanceof JTextArea) {
      return (int) ((JTextArea) c).getUI().getRootView((JTextArea) c).getPreferredSpan(javax.swing.text.View.Y_AXIS);
    }*/
    return c.getMinimumSize().height;
  }

  private 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) {
      /* old method of calculating numRows:
      int numRows = 0;
      for (String key : map.keySet()) {
        if (key.length() == 1)
          numRows = Math.max(numRows, Character.toLowerCase(key.charAt(0))-'a');
      }*/
      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) {
      // LEFT_CHAR + LEFT_CHAR is a 2-character repeating sequence
      // which indicates a wide component. So you can theoretically
      // use LetterLayout.LEFT_CHAR as your "main" component's...
      // but it doesn't seem to work. Just use centerAndEast etc
      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) };
    }
  }

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

  private static void determineStarts(RC[] rcs, int start, int totalSize, int spacing) {
    int minTotal = rcs[rcs.length - 1].minEnd;
    double weightSum = rcs[rcs.length - 1].weightSum;
    //System.out.println("totalSize="+totalSize+",minTotal="+minTotal+",weightSum="+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;
      //System.out.println("i="+i+",prevws="+prevWeightSum+",ws="+rcs[i].weightSum+",min="+rcs[i].min+",width="+width);
      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);
  }

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

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

  /**
   * layout components from top to bottom; add components without letters!
   */
  public static LetterLayout stalactite() {
    return new LetterLayout(STALACTITE);
  }

  /**
   * layout components from left to right; add components without letters!
   */
  public static LetterLayout leftAlignedRow() {
    return new LetterLayout(LEFT_ALIGNED_ROW);
  }

  public static LetterLayout leftAlignedRow(int spacing) {
    return leftAlignedRow().setSpacing(spacing);
  }

  /**
   * layout components from left to right, center in container; add components without letters!
   */
  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);
  }

  private static JPanel makePanel(LetterLayout letterLayout, JComponent[] components) {
    JPanel panel = new JPanel(letterLayout);
    for (JComponent component : components) {
      panel.add(component);
    }
    return panel;
  }

  /**
   * layout components from top to bottom; two components per row
   */
  public static LetterLayout form() {
    LetterLayout letterLayout = new LetterLayout(FORM);
    letterLayout.formWideLeftSide = true;
    letterLayout.formWideRightSide = true;
    return letterLayout;
  }

  /**
   * layout components from top to bottom; two components per row
   * left column is small, right column is wide
   */
  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 void setSelectedIndex(final JList l, final int i) {
  if (l != null) { swing(() -> {  l.setSelectedIndex(i); }); }
}

static void setSelectedIndex(final JComboBox cb, final int i) {
  if (cb != null) { swing(() -> {  cb.setSelectedIndex(i); }); }
}


static <A extends JTextComponent> A setEditable(A a, boolean b) {
  if (a != null) { swing(() -> {  a.setEditable(b); }); }
  return a;
}


static void copyArrayToVector(Object[] array, Vector v) {
  v.clear();
  v.addAll(toList(array));
}


static void swing_standardTabBehavior(KeyEvent key) {
  if ((key.getModifiers() & ActionEvent.SHIFT_MASK) != 0)
    KeyboardFocusManager.getCurrentKeyboardFocusManager().focusPreviousComponent();
  else
    KeyboardFocusManager.getCurrentKeyboardFocusManager().focusNextComponent();
}



static boolean emptyAfterTrim(String s) {
  return empty(trim(s));
}


static List<String> scoredSearch(String query, Iterable<String> data) {
  Map<String, Integer> scores = new HashMap();
  List<String> searchTerms = scoredSearch_prepare(query);
  if (empty(searchTerms)) return asList(data);
  for (String s : data) {
    int score = scoredSearch_score(s, searchTerms);
    if (score != 0)
      scores.put(s, score);
  }
  return keysSortedByValuesDesc(scores);
}


static void arrayCopy(Object[] a, Object[] b) {
  arraycopy(a, b);
}



static void arrayCopy(Object src, Object dest, int destPos, int n) { arrayCopy(src, 0, dest, destPos, n); }
static void arrayCopy(Object src, int srcPos, Object dest, int destPos, int n) {
  arraycopy(src, srcPos, dest, destPos, n);
}


static File prepareFile(File file) {
  return mkdirsForFile(file);
}

static File prepareFile(File dir, String name) {
  return mkdirsForFile(newFile(dir, name));
}


static void savePNG(BufferedImage img, File file) { try {
  File tempFile = new File(file.getPath() + "_temp");
  CriticalAction ca = beginCriticalAction("Save " + f2s(file));
  try {
    ImageIO.write(img, "png", mkdirsFor(tempFile));
    file.delete();
    tempFile.renameTo(file);
  } finally {
    ca.done();
  }
} catch (Exception __e) { throw rethrow(__e); } }

// gotta love convenience & program-smartness
static void savePNG(String file, BufferedImage img) { savePNG(toFile(file), img); }

static void savePNG(File file, BufferedImage img) {
  savePNG(img, file);
}


static void savePNG(File file, RGBImage img) {
  savePNG(file, img.getBufferedImage());
}



static RGBImage loadImage(String snippetIDOrURL) {
  return new RGBImage(loadBufferedImage(snippetIDOrURL));
}

static RGBImage loadImage(File f) {
  return new RGBImage(loadBufferedImage(f));
}


static BufferedImage loadImage2(String snippetIDOrURL) {
  return loadBufferedImage(snippetIDOrURL);
}

static BufferedImage loadImage2(File file) {
  return loadBufferedImage(file);
}


static String md5OfBufferedImage(BufferedImage img) {
  return img == null ? null : rgbMD5(new RGBImage(img));
}


static long sysTime() {
  return sysNow();
}


static Map mapValues(Object func, Map map) {
  Map m = similarEmptyMap(map);
  for (Object key : keys(map))
    m.put(key, callF(func, map.get(key)));
  return m;
}

static <A, B, C> Map<A, C> mapValues(Map<A, B> map, IF1<B, C> f) {
  return mapValues(f, map);
}

static <A, B, C> Map<A, C> mapValues(IF1<B, C> f, Map<A, B> map) {
  Map m = similarEmptyMap(map);
  for (Map.Entry<? extends A, ? extends B> __0 : _entrySet( map))
    { A key = __0.getKey(); B val = __0.getValue();  m.put(key, f.get(val)); }
  return m;
}

static Map mapValues(Map map, Object func) {
  return mapValues(func, map);
}


  static <A, B, C> MultiMap<A, C> mapValues(IF1<B, C> func, MultiMap<A, B> mm) {
    return mapMultiMapValues(func, mm);
  }
  
  static <A, B, C> MultiMap<A, C> mapValues(MultiMap<A, B> mm, IF1<B, C> func) {
    return mapValues(func, mm);
  }



static <A, B> boolean isA(Either<A, B> e) {
  return eitherIsA(e);
}


static 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 int getMinimumHeight(final Component c) {
  return getMinimumSize(c).height;
}


static 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 List<String> scoredSearch_prepare(String query) {
  return map(__117 -> replacePlusWithSpace(__117), splitAtSpace(query));
}


// Search for some words in some texts and return a total score
static 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 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 int scoredSearch_score(String s, String query) {
  return scoredSearch_score(s, scoredSearch_prepare(query));
}


static <A, B> List<A> keysSortedByValuesDesc(final Map<A, B> map) {
  List<A> l = new ArrayList(map.keySet());
  sort(l, mapComparatorDesc(map));
  return l;
}


static List<CriticalAction> beginCriticalAction_inFlight = synchroList();

static class CriticalAction implements AutoCloseable {
  String description;
  
  CriticalAction() {}
  CriticalAction(String description) {
  this.description = description;}
  
  final public void close(){ done(); }
public void done() {
    beginCriticalAction_inFlight.remove(this);
  }
}

static CriticalAction beginCriticalAction(String description) {
  ping();
  CriticalAction c = new CriticalAction(description);
  beginCriticalAction_inFlight.add(c);
  return c;
}

static void cleanMeUp_beginCriticalAction() {
  int n = 0;
  while (nempty(beginCriticalAction_inFlight)) {
    int m = l(beginCriticalAction_inFlight);
    if (m != n) {
      n = m;
      try {
        print("Waiting for " + n2(n, "critical actions") + ": " + join(", ", collect(beginCriticalAction_inFlight, "description")));
      } catch (Throwable __e) { pcallFail(__e); }
    }
    sleepInCleanUp(10);
  }
}


static File toFile(Object o) {
  if (o instanceof File) return (File) o;
  if (o instanceof String) return new File((String) o);
  throw fail("Not a file: " + o);
}


static String rgbMD5(RGBImage img) {
  return md5OfRGBImage(img);
}


static MultiMap mapMultiMapValues(Object func, MultiMap mm) {
  MultiMap m = similarEmptyMultiMap(mm);
  for (Object key : keys(mm))
    for (Object value : mm.get(key))
      m.put(key, callF(func, value));
  return m;
}

static MultiMap mapMultiMapValues(MultiMap mm, Object func) {
  return mapMultiMapValues(func, mm);
}

static <A, B, C> MultiMap<A, C> mapMultiMapValues(IF1<B, C> func, MultiMap<A, B> mm) {
  return mapMultiMapValues((Object) func, mm);
}


static <A, B> boolean eitherIsA(Either<A, B> e) {
  return e != null && e.isA();
}




static String replacePlusWithSpace(String s) {
  return replace(s, '+', ' ');
}


static 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 <A, B> Comparator<A> mapComparatorDesc(final Map<A, B> map) {
  return new Comparator<A>() {
    public int compare(A a, A b) {
      return cmp(map.get(b), map.get(a));
    }
  };
}


static String md5OfRGBImage(RGBImage img) { try {
  MessageDigest m = MessageDigest.getInstance("MD5");
  m.update(intToBytes(img.getWidth()));
  int[] pixels = img.getPixels();
  for (int i = 0; i < l(pixels); i++)
    m.update(intToBytes(pixels[i]));
  return bytesToHex(m.digest());
} catch (Exception __e) { throw rethrow(__e); } }


// TODO: comparators!?
static MultiMap similarEmptyMultiMap(MultiMap m) {
  if (m instanceof TreeMultiMap)
    return new TreeMultiMap((TreeMultiMap) m);
  return similarEmptyMultiMap(m == null ? null : m.data);
}

static MultiMap similarEmptyMultiMap(Map m) {
  MultiMap mm = new MultiMap();
  if (m != null)
    mm.data = similarEmptyMap(m);
  return mm;
}




static 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))) { /* matching char */ }
      else continue elsewhere;
    }
    return i;
  }
  return -1;
}




static class TreeMultiMap<A, B> extends MultiMap<A, B> {
  TreeMultiMap() { super(true); }
  TreeMultiMap(MultiMap<A, B> map) { this(); putAll(map); }
  
  NavigableMap<A, List<B>> innerMap() { return (NavigableMap) data; }
}
static class RGBImage implements MakesBufferedImage, IRGBImage {
  transient BufferedImage bufferedImage;
  int width, height;
  int[] pixels;

  RGBImage() {}

  RGBImage(BufferedImage image) {
    bufferedImage = image;
    width = image.getWidth();
    height = image.getHeight();
    pixels = new int[width*height];
    var gp = grabbableIntPixels_fastOrSlow(image);
    
    if (gp.scanlineStride == width && gp.offset == 0)
      pixels = gp.data;
    else {
      pixels = new int[width*height];
      int iIn = 0, iOut = 0;
      for (int y = 0; y < height; y++) {
        arrayCopy(gp.data, iIn, pixels, iOut, width);
        iIn += gp.scanlineStride;
        iOut += width;
      }
    }
    
    cleanPixels(); // set upper byte to 0
  }

  RGBImage(Dimension size, Color color) {
    this(size.width, size.height, color);
  }

  RGBImage(Dimension size, RGB color) {
    this(size.width, size.height, color);
  }

  private void cleanPixels() {
    var pixels = this.pixels;
    for (int i = 0; i < pixels.length; i++)
      pixels[i] &= 0xFFFFFF;
  }

  RGBImage(int width, int height, int[] pixels) {
    this.width = width;
    this.height = height;
    this.pixels = pixels;
  }

  RGBImage(int w, int h, RGB[] pixels) {
    this.width = w;
    this.height = h;
    this.pixels = asInts(pixels);
  }

  public static int[] asInts(RGB[] pixels) {
    int[] ints = new int[pixels.length];
    for (int i = 0; i < pixels.length; i++)
      ints[i] = pixels[i] == null ? 0 : pixels[i].getColor().getRGB();
    return ints;
  }

  public RGBImage(int w, int h) {
    this(w, h, Color.black);
  }
  
  RGBImage(int w, int h, RGB rgb) {
    this.width = w;
    this.height = h;
    this.pixels = new int[w*h];
    int col = rgb.asInt();
    if (col != 0)
      for (int i = 0; i < pixels.length; i++)
        pixels[i] = col;
  }

  RGBImage(RGBImage image) {
    this(image.width, image.height, copyPixels(image.pixels));
  }

  RGBImage(int width, int height, Color color) {
    this(width, height, new RGB(color));
  }

  RGBImage(MakesBufferedImage img) {
    this(toBufferedImage(img));
  }

  private static int[] copyPixels(int[] pixels) {
    int[] copy = new int[pixels.length];
    System.arraycopy(pixels, 0, copy, 0, pixels.length);
    return copy;
  }

  public int getIntPixel(int x, int y) {
    if (inRange(x, y))
      return pixels[y * width + x];
    else
      return 0xFFFFFF;
  }
  
  // idx = index in pixel array
  public int getIntPixel_noRangeCheck(int idx) {
    return pixels[idx];
  }

  public static RGB asRGB(int packed) {
    int r = (packed >> 16) & 0xFF;
    int g = (packed >> 8) & 0xFF;
    int b = packed & 0xFF;
    return new RGB(r / 255f, g / 255f, b / 255f);
  }

  public RGB getRGB(int x, int y) {
    if (inRange(x, y))
      return asRGB(pixels[y * width + x]);
    else
      return new RGB(0xFFFFFF);
  }

  /** alias of getRGB - I kept typing getPixel instead of getRGB all the time, so I finally created it */
  RGB getPixel(int x, int y) {
    return getRGB(x, y);
  }
  
  RGB getPixel(Pt p) { return getPixel(p.x, p.y); }

  public int getWidth() { return width; }
  public int getHeight() { return height; }
  public int w() { return width; }
  public int h() { return height; }

  /** Attention: cached, i.e. does not change when image itself changes */
  /** @NotNull */
  public BufferedImage getBufferedImage() {
    if (bufferedImage == null) {
      bufferedImage = new BufferedImage(width, height, BufferedImage.TYPE_INT_RGB);
      //bufferedImage.setData(Raster.createRaster(new SampleModel()));
      for (int y = 0; y < height; y++)
        for (int x = 0; x < width; x++)
          bufferedImage.setRGB(x, y, pixels[y*width+x]);
    }
    return bufferedImage;
  }

  RGBImage clip(Rect r) {
    return r == null ? null : clip(r.getRectangle());
  }
  
  RGBImage clip(Rectangle r) {
    r = fixClipRect(r);
    if (r.x == 0 && r.y == 0 && r.width == width && r.height == height) return this;
    int[] newPixels;
    try {
      newPixels = new int[r.width*r.height];
    } catch (RuntimeException e) {
      System.out.println(r);
      throw e;
    }
    for (int y = 0; y < r.height; y++) {
      System.arraycopy(pixels, (y+r.y)*width+r.x, newPixels, y*r.width, r.width);
    }
    return new RGBImage(r.width, r.height, newPixels);
  }

  private Rectangle fixClipRect(Rectangle r) {
    r = r.intersection(new Rectangle(0, 0, width, height));
    if (r.isEmpty())
      r = new Rectangle(r.x, r.y, 0, 0);
    return r;
  }

  public int getInt(int x, int y) {
    return pixels[y * width + x];
  }

  public void save(File file) {
    saveImage(file, getBufferedImage());
  }

  public static RGBImage dummyImage() {
    return new RGBImage(1, 1, new int[] {0xFFFFFF});
  }

  public int[] getPixels() {
    return pixels;
  }
  
  void setPixel(int x, int y, int r, int g, int b) {
    if (x >= 0 && y >= 0 && x < width && y < height)
      pixels[y*width+x] = (limitToUByte(r) << 16) | (limitToUByte(g) << 8) | limitToUByte(b);
  }

  public void setPixel(int x, int y, RGB rgb) {
    if (x >= 0 && y >= 0 && x < width && y < height)
      pixels[y*width+x] = rgb.asInt();
  }

  final public void set(int x, int y, Color color){ setPixel(x, y, color); }
public void setPixel(int x, int y, Color color) {
    setPixel(x, y, new RGB(color));
  }
  
  void setInt(int x, int y, int rgb) {
    setPixel(x, y, rgb);
  }

  public void setPixel(int x, int y, int rgb) {
    if (x >= 0 && y >= 0 && x < width && y < height)
      pixels[y*width+x] = rgb;
  }
  
  void setPixel(Pt p, RGB rgb) { setPixel(p.x, p.y, rgb); }
  void setPixel(Pt p, Color color) { setPixel(p.x, p.y, color); }

  public RGBImage copy() {
    return new RGBImage(this);
  }

  public boolean inRange(int x, int y) {
    return x >= 0 && y >= 0 && x < width && y < height;
  }

  public Dimension getSize() {
    return new Dimension(width, height);
  }

  @Override
  public boolean equals(Object o) {
    if (this == o) return true;
    if (o == null || getClass() != o.getClass()) return false;

    RGBImage rgbImage = (RGBImage) o;

    if (height != rgbImage.height) return false;
    if (width != rgbImage.width) return false;
    if (!Arrays.equals(pixels, rgbImage.pixels)) return false;

    return true;
  }

  @Override
  public int hashCode() {
    int result = width;
    result = 31 * result + height;
    result = 31 * result + Arrays.hashCode(pixels);
    return result;
  }

  public String getHex(int x, int y) {
    return getPixel(x, y).getHexString();
  }

  public RGBImage clip(int x, int y, int width, int height) {
    return clip(new Rectangle(x, y, width, height));
  }

  public RGBImage clipLine(int y) {
    return clip(0, y, width, 1);
  }

  public int numPixels() {
    return width*height;
  }
  
  RGBImage uncacheBufferedImage() {
    bufferedImage = null;
    return this;
  }
}



static interface IRGBImage extends MakesBufferedImage {
  int getIntPixel(int x, int y);
}
static class RGB {
  // usually in range [0, 1]
  public float r, g, b; // can't be final cause persistence
  
  RGB() {}
  
  public RGB(float brightness) {
    r = g = b = brightness;
  }
  
  public RGB(float r, float g, float b) {
    this.r = r;
    this.g = g;
    this.b = b;
  }

  public RGB(double r, double g, double b) {
    this.r = (float) r;
    this.g = (float) g;
    this.b = (float) b;
  }
  
  public RGB(double[] rgb) {
    this(rgb[0], rgb[1], rgb[2]);
  }

  public RGB(int rgb) {
    r = rgbRed(rgb)/255f;
    g = rgbGreen(rgb)/255f;
    b = rgbBlue(rgb)/255f;
  }
  
  public RGB(double brightness) {
    this((float) brightness);
  }

  public RGB(Color color) {
    r = color.getRed()/255f;
    g = color.getGreen()/255f;
    b = color.getBlue()/255f;
  }

  // TODO: 3-char version
  public RGB(String hex) {
    int i = l(hex)-6;
    r = Integer.parseInt(hex.substring(i, i+2), 16)/255f;
    g = Integer.parseInt(hex.substring(i+2, i+4), 16)/255f;
    b = Integer.parseInt(hex.substring(i+4, i+6), 16)/255f;
  }

  public float getComponent(int i) {
    return i == 0 ? r : i == 1 ? g : b;
  }

  public int getInt(int i) {
    return i == 0 ? redInt() : i == 1 ? greenInt() : blueInt();
  }
  
  public Color getColor() {
    return new Color(clampZeroToOne(r), clampZeroToOne(g), clampZeroToOne(b));
  }

  public static RGB newSafe(float r, float g, float b) {
    return new RGB(Math.max(0, Math.min(1, r)), Math.max(0, Math.min(1, g)), Math.max(0, Math.min(1, b)));
  }

  int asInt() { return getColor().getRGB() & 0xFFFFFF; }
  int getInt() { return getColor().getRGB() & 0xFFFFFF; }
  int asIntWithAlpha() { return rgbInt(redInt(), greenInt(), blueInt()) | 0xFF000000; }

  final public float brightness(){ return getBrightness(); }
public float getBrightness() {
    return (r+g+b)/3.0f;
  }

  public String getHexString() {
    return Integer.toHexString(asInt() | 0xFF000000).substring(2).toUpperCase();
  }

  @Override
  public boolean equals(Object o) {
    if (this == o) return true;
    if (!(o instanceof RGB)) return false;

    RGB rgb = (RGB) o;

    if (Float.compare(rgb.b, b) != 0) return false;
    if (Float.compare(rgb.g, g) != 0) return false;
    if (Float.compare(rgb.r, r) != 0) return false;

    return true;
  }

  @Override
  public int hashCode() {
    int result = (r != +0.0f ? Float.floatToIntBits(r) : 0);
    result = 31 * result + (g != +0.0f ? Float.floatToIntBits(g) : 0);
    result = 31 * result + (b != +0.0f ? Float.floatToIntBits(b) : 0);
    return result;
  }

  public boolean isBlack() {
    return r == 0f && g == 0f && b == 0f;
  }

  public boolean isWhite() {
    return r == 1f && g == 1f && b == 1f;
  }
  
  // This is hyperprecise
  boolean isGrayscale() {
    return r == g && g == b;
  }

  public String toString() {
    //return getHexString();
    return isGrayscale() ? formatChannel(r)
      : spaceCombine("RGB", formatChannel(r), formatChannel(g), formatChannel(b));
  }
  
  String formatChannel(float value) {
    return formatDouble(value, 2);
  }
  
  int redInt() { return iround(r*255); }
  int greenInt() { return iround(g*255); }
  int blueInt() { return iround(b*255); }
  
  static float brightnessToFloat(int brightness) { return brightness/255f; }
  
  RGB cloneMe() { return new RGB(r, g, b); }
}


static BufferedImage toBufferedImage(Object o) {
  return toBufferedImageOpt(o);
}


static boolean inRange(int x, int n) {
  return x >= 0 && x < n;
}

static boolean inRange(int x, List l) {
  return inRange(x, l(l));
}

static boolean inRange(int x, int a, int b) {
  return x >= a && x < b;
}


static int getPixel(BufferedImage img, int x, int y) {
  return img.getRGB(x, y);
}

static int getPixel(BufferedImage img, Pt p) {
  return img.getRGB(p.x, p.y);
}


static void saveImage(File f, BufferedImage img) {
  if (hasJPEGExtension(f))
    saveJPG(f, img);
  else
    savePNG(f, img);
}

static void saveImage(BufferedImage img, File f) {
  saveImage(f, img);
}


static int limitToUByte(int i) {
  return max(0, min(255, i));
}


static void setPixel(BufferedImage img, int p_x, int p_y, Color color) { setPixel(img, pt(p_x, p_y), color); }

static void setPixel(BufferedImage img, Pt p, Color color) {
  { if (img != null) img.setRGB(p.x, p.y, colorToIntOpaque(color)); }
}

static void setPixel(Graphics2D g, int p_x, int p_y, Color color) { setPixel(g, pt(p_x, p_y), color); }

static void setPixel(Graphics2D g, Pt p, Color color) {
  g.setColor(color);
  g.drawRect(p.x, p.y, 1, 1);
}


static int rgbRed(int rgb) {
  return (rgb >> 16) & 0xFF;
}


static int rgbGreen(int rgb) {
  return (rgb >> 8) & 0xFF;
}


static int rgbBlue(int rgb) {
  return rgb & 0xFF;
}


static Color getColor(BufferedImage img, int x, int y) {
  return colorFromRGBA(img.getRGB(x, y));
}

static Color getColor(BufferedImage img, Pt p) {
  return colorFromRGBA(img.getRGB(p.x, p.y));
}



  static float clampZeroToOne(float x) {
    return x < 0 ? 0 : x > 1 ? 1 : x;
  }


  static double clampZeroToOne(double x) {
    return x < 0 ? 0 : x > 1 ? 1 : x;
  }




static int rgbInt(int r, int g, int b) {
  return (clamp(r, 0, 255) << 16) | (clamp(g, 0, 255) << 8) | clamp(b, 0, 255);
}

static int rgbInt(byte r, byte g, byte b) {
  return (ubyteToInt(r) << 16) | (ubyteToInt(g) << 8) | ubyteToInt(b);
}


static String spaceCombine(Object... l) {
  return joinNemptiesWithSpace(flattenCollections(ll(l)));
}




static boolean hasJPEGExtension(File f) {
  return ewicOneOf(fileName(f), ".jpg", ".jpeg");
}


static void saveJPG(BufferedImage img, File file) { try {
  if (!ImageIO.write(img, "jpeg", mkdirsFor(file))) {
    print("Reconstructing image for saving JPEG");
    img = reconstructBufferedImage(img);
    if (!ImageIO.write(img, "jpeg", file))
      throw fail("Couldn't write JPEG: " + file + " (" + img + ")");
  }
  vmBus_send("wroteFile", file);
} catch (Exception __e) { throw rethrow(__e); } }

static void saveJPG(File file, BufferedImage img) { try {
  saveJPG(img, file);
} catch (Exception __e) { throw rethrow(__e); } }


static int colorToIntOpaque(Color c) {
  return c.getRGB() | 0xFF000000;
}


static Color colorFromRGBA(int rgba) {
  return new Color(rgba, true);
}


static String joinNemptiesWithSpace(String... strings) {
  return joinNempties(" ", strings);
}

static String joinNemptiesWithSpace(Collection<String> strings) {
  return joinNempties(" ", strings);
}


static List flattenCollections(Iterable a) {
  List l = new ArrayList();
  for (Object x : a)
    if (x instanceof Collection)
      l.addAll(flattenCollections((Collection) x));
    else
      l.add(x);
  return l;
}




static BufferedImage reconstructBufferedImage(BufferedImage img) {
  if (img == null) return null;
  RGBImage rgb = new RGBImage(img);
  rgb.uncacheBufferedImage();
  return rgb.getBufferedImage();
}



}