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 javax.imageio.*;
import java.math.*;
import static x30_pkg.x30_util.DynamicObject;
import org.eclipse.collections.impl.map.mutable.primitive.*;
import org.eclipse.collections.impl.set.mutable.primitive.*;
import org.eclipse.collections.api.tuple.primitive.*;
import org.eclipse.collections.api.iterator.*;
import java.text.NumberFormat;

class main {

  static class SharedPhrases_characterMode extends Stages implements IVar<List<String>> {

    // you can access this directly if you use one thread
    List<String> v;

    public synchronized void set(List<String> a) {
      if (v != a) {
        v = a;
        notifyAll();
      }
    }

    public synchronized List<String> get() {
      run();
      return v;
    }

    public synchronized boolean has() {
      return v != null;
    }

    public void clear() {
      set(null);
    }

    SharedPhrases_characterMode(String... strings) {
      addAll(this.strings, strings);
    }

    SharedPhrases_characterMode(Collection<String> strings) {
      addAll(this.strings, strings);
    }

    List<String> strings = new ArrayList();

    int minLength = 2;

    List<List<String>> lineSplits;

    Set<String> ci;

    // stage 1. split all the lines
    {
      stage(new Runnable() {

        public void run() {
          try {
            lineSplits = stringsToLineCompSplits(strings);
          } catch (Exception __e) {
            throw rethrow(__e);
          }
        }

        public String toString() {
          return "lineSplits = stringsToLineCompSplits(strings);";
        }
      });
    }

    // stage 2. find similarities
    {
      stage(new Runnable() {

        public void run() {
          try {
            ci = intersectCISets(lineSplits);
          } catch (Exception __e) {
            throw rethrow(__e);
          }
        }

        public String toString() {
          return "ci = intersectCISets(lineSplits);";
        }
      });
    }

    // stage 3. forget the one letter stuff and sort by length (LONG first of course)
    {
      stage(new Runnable() {

        public void run() {
          try {
            set(longStrings(ci, minLength));
          } catch (Exception __e) {
            throw rethrow(__e);
          }
        }

        public String toString() {
          return "set(longStrings(ci, minLength));";
        }
      });
    }
    // bring together Stages & Var
  }

  static List<String> sharedPhrases_characterMode(String... strings) {
    return new SharedPhrases_characterMode(strings).get();
  }

  // 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 Class run(String progID, String... args) {
    Class main = hotwire(progID);
    callMain(main, args);
    return main;
  }

  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 <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 List<List<String>> stringsToLineCompSplits(List<String> strings) {
    return valuesList(lcEncodingsAsStringLists(lcByteMode(listToStringCountKeys(strings))));
  }

  static List<List<String>> stringsToLineCompSplits(String... strings) {
    return stringsToLineCompSplits(asList(strings));
  }

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

  static Set<String> intersectCISets(Collection<String> a, Collection<String> b) {
    return setIntersection(asCISet(a), asCISet(b));
  }

  static <A extends Collection<String>> Set<String> intersectCISets(Collection<A> l) {
    Set<String> set = null;
    for (Collection<String> x : unnullForIteration(l)) set = set == null ? asCISet(x) : intersectCISets(set, x);
    return set;
  }

  static List<String> longStrings(Collection<String> l) {
    return longStrings(1, l);
  }

  static List<String> longStrings(int minLength, Collection<String> l) {
    return stringsSortedByDecreasingLength(longerThan(minLength - 1, l));
  }

  static List<String> longStrings(Collection<String> l, int minLength) {
    return longStrings(minLength, l);
  }

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

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

  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(Object o) {
    return o == null ? 0 : o instanceof String ? l((String) o) : o instanceof Map ? l((Map) o) : o instanceof Collection ? l((Collection) o) : o instanceof Object[] ? l((Object[]) o) : o instanceof boolean[] ? l((boolean[]) o) : o instanceof byte[] ? l((byte[]) o) : o instanceof char[] ? l((char[]) o) : o instanceof short[] ? l((short[]) o) : o instanceof int[] ? l((int[]) o) : o instanceof float[] ? l((float[]) o) : o instanceof double[] ? l((double[]) o) : o instanceof long[] ? l((long[]) o) : (Integer) call(o, "size");
  }

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

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

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

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

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

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

  // 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 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;
      }
      throw e;
    }
  }

  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 Map<String, List<String>> lcEncodingsAsStringLists(LineCompCompressor lc) {
    return mapValues(lc.finalEncodings, l -> map(l, i -> lc.itemToString(i)));
  }

  static LineCompCompressor lcByteMode(Map<String, String> data) {
    return lcByteMode(new LineCompCompressor(), data);
  }

  static LineCompCompressor lcByteMode(LineCompCompressor compressor, Map<String, String> data) {
    compressor.byteMode = true;
    compressor.loadTexts(data);
    compressor.run();
    return compressor;
  }

  static <A> Map<String, A> listToStringCountKeys(List<A> l) {
    return listToMapWithKeyMaker(l, i -> str(i + 1));
  }

  // 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<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> List<A> asList(Pair<A, A> p) {
    return p == null ? null : ll(p.a, p.b);
  }

  static void _handleError(Error e) {
    call(javax(), "_handleError", e);
  }

  static <A> Set<A> setIntersection(Collection<A> a, Collection<A> b) {
    Set<A> set = similarEmptySet(a);
    if (nempty(a) && nempty(b)) {
      Set<A> bSet = asSet(b);
      for (A x : a) if (bSet.contains(x))
        set.add(x);
    }
    return set;
  }

  static TreeSet<String> asCISet(Iterable<String> c) {
    return toCaseInsensitiveSet(c);
  }

  static TreeSet<String> asCISet(String... x) {
    return toCaseInsensitiveSet(x);
  }

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

  // 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 List<String> stringsSortedByDecreasingLength(Collection<String> l) {
    return sortedByDesc(__19 -> l(__19), l);
  }

  static List<String> longerThan(Iterable<String> l, int x) {
    return filter(l, s -> l(s) > x);
  }

  static List<String> longerThan(int x, Iterable<String> l) {
    return longerThan(l, x);
  }

  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 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 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 String mainClassNameForClassLoader(ClassLoader cl) {
    return or((String) callOpt(cl, "mainClassName"), "main");
  }

  static void assertFalse(Object o) {
    if (!(eq(o, false)))
      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 _inCore() {
    return false;
  }

  static Class __javax;

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

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

  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 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 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 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 Object callOpt(Object o) {
    return callF(o);
  }

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

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

  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 <A> ArrayList<A> cloneListSynchronizingOn(Collection<A> l, Object mutex) {
    if (l == null)
      return new ArrayList();
    synchronized (mutex) {
      return new ArrayList<A>(l);
    }
  }

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

  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)
      for (A o : l) {
        ping();
        x.add(f.get(o));
      }
    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 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);
  }

  // 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 <A, B, C> List<C> map(Map<A, B> map, IF2<A, B, C> f) {
    return map(map, (Object) f);
  }

  // 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 <A, B> LinkedHashMap<A, B> listToMapWithKeyMaker(List<B> l, IF1<Integer, A> f) {
    LinkedHashMap<A, B> map = new LinkedHashMap();
    int n = l(l);
    for (int i = 0; i < n; i++) map.put(f.get(i), l.get(i));
    return map;
  }

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

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

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

  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 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(MultiMap mm) {
    return mm != null && !mm.isEmpty();
  }

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

  static boolean nempty(IntBuffer b) {
    return b != null && !b.isEmpty();
  }

  static boolean nempty(LongBuffer b) {
    return b != null && !b.isEmpty();
  }

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

  static TreeSet<String> toCaseInsensitiveSet(Iterable<String> c) {
    if (isCISet(c))
      return (TreeSet) c;
    TreeSet<String> set = caseInsensitiveSet();
    addAll(set, c);
    return set;
  }

  static TreeSet<String> toCaseInsensitiveSet(String... x) {
    TreeSet<String> set = caseInsensitiveSet();
    addAll(set, x);
    return set;
  }

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

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

  // f: A -> Comparable
  static <A> List<A> sortedByDesc(Collection<A> c, final Object f) {
    return sortByCalculatedFieldDesc(c, f);
  }

  static <A> List<A> sortedByDesc(Object f, Collection<A> c) {
    return sortByCalculatedFieldDesc(f, c);
  }

  static <A, B> List<A> sortedByDesc(Iterable<A> c, IF1<A, B> f) {
    return sortByCalculatedFieldDesc(c, f);
  }

  static <A, B> List<A> sortedByDesc(IF1<A, B> f, Iterable<A> c) {
    return sortByCalculatedFieldDesc(f, c);
  }

  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
  // not redirected
  static volatile StringBuffer local_log = new StringBuffer();

  static boolean printAlsoToSystemOut = true;

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

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

  static volatile int local_log_max = 100 * 1024;

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

  static Object print_byThread_lock = new Object();

  // special handling by thread - prefers F1<S, Bool>
  static volatile ThreadLocal<Object> print_byThread;

  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 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(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) {
      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 Object call_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.findStaticMethod(method, args);
        if (me != null)
          return invokeMethod(me, null, args);
        // try varargs
        List<Method> methods = cache.cache.get(method);
        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() + "." + method + "(" + joinWithComma(classNames(args)) + ") not found");
      } 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);
          }
        throw fail("Method " + c.getName() + "." + method + "(" + joinWithComma(classNames(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 <A> A or(A a, A b) {
    return a != null ? a : 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 void _onJavaXSet() {
  }

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

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

  static void setOptIfNotNull(Object o, String field, Object value) {
    if (value != null)
      setOpt(o, field, value);
  }

  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 Object mainBot;

  static Object getMainBot() {
    return mainBot;
  }

  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)
        // in class init
        map = getOpt_makeCache(c);
      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
        setOpt_raw(o, field, value);
        return;
      }
      Field f = map.get(field);
      if (f != null) // possible improvement: skip setAccessible
      {
        smartSet(f, o, value);
        return;
      }
      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 {
      // TODO: optimize
      Field f = setOpt_findStaticField(c, field);
      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 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 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 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;
  }

  // << collapsed words, so "corect" means "correct"
  static List<String> isYes_yesses = litlist("y", "yes", "yeah", "y", "yup", "yo", "corect", "sure", "ok", "afirmative");

  static boolean isYes(String s) {
    return isYes_yesses.contains(collapseWord(toLowerCase(firstWord2(s))));
  }

  // TODO: JDK 17!! ?? No! Yes? Yes!!
  static Object collectionMutex(List l) {
    return l;
  }

  static Object collectionMutex(Object o) {
    if (o instanceof List)
      return o;
    String c = className(o);
    if (eq(c, "java.util.TreeMap$KeySet"))
      c = className(o = getOpt(o, "m"));
    else if (eq(c, "java.util.HashMap$KeySet"))
      c = className(o = get_raw(o, "this$0"));
    if (eqOneOf(c, "java.util.TreeMap$AscendingSubMap", "java.util.TreeMap$DescendingSubMap"))
      c = className(o = get_raw(o, "m"));
    return 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 int max(Collection<Integer> c) {
    int x = Integer.MIN_VALUE;
    for (int i : c) x = max(x, i);
    return 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 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 <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, B> Set<A> keys(MultiMap<A, B> mm) {
    return mm.keySet();
  }

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

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

  // sbool ping_actions_shareable = true;
  static volatile boolean ping_pauseAll = false;

  // poll pauseAll flag every 100
  static int ping_sleep = 100;

  static volatile boolean ping_anyActions = false;

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

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

  // always returns true
  static boolean ping() {
    // ifdef useNewPing
    newPing();
    // endifdef
    if (ping_pauseAll || ping_anyActions)
      ping_impl(true);
    // 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 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(MultiMap mm) {
    return mm == null || mm.isEmpty();
  }

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

  static boolean empty(IntBuffer b) {
    return b == null || b.isEmpty();
  }

  static boolean empty(LongBuffer b) {
    return b == null || b.isEmpty();
  }

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

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

  // 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 boolean isCISet(Iterable<String> l) {
    return l instanceof TreeSet && ((TreeSet) l).comparator() == caseInsensitiveComparator();
  }

  static TreeSet<String> caseInsensitiveSet() {
    return caseInsensitiveSet_treeSet();
  }

  static TreeSet<String> caseInsensitiveSet(Collection<String> c) {
    return caseInsensitiveSet_treeSet(c);
  }

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

  // f: A -> Comparable
  static <A> List<A> sortByCalculatedFieldDesc(Collection<A> c, final Object f) {
    return sortByCalculatedFieldDesc_inPlace(cloneList(c), f);
  }

  static <A> List<A> sortByCalculatedFieldDesc(Object f, Collection<A> c) {
    return sortByCalculatedFieldDesc(c, f);
  }

  static <A, B> List<A> sortByCalculatedFieldDesc(Iterable<A> c, IF1<A, B> f) {
    List<A> l = cloneList(c);
    sort(l, new Comparator<A>() {

      public int compare(A a, A b) {
        return stdcompare(f.get(b), f.get(a));
      }
    });
    return l;
  }

  static <A, B> List<A> sortByCalculatedFieldDesc(IF1<A, B> f, Iterable<A> c) {
    return sortByCalculatedFieldDesc(c, f);
  }

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

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

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

  // 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 final Map<Class, HashMap<S, Field>> getOpt_cache = _registerWeakMap(synchroMap(new getOpt_Map));
  // just a marker
  static HashMap getOpt_special;

  /*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 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 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 <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 String getClassName(Object o) {
    return o == null ? "null" : o instanceof Class ? ((Class) o).getName() : o.getClass().getName();
  }

  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 != args.length) {
      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 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(Method m, Object[] args) {
    Class<?>[] types = m.getParameterTypes();
    int n = types.length - 1, nArgs = args.length;
    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);
    Object[] varArgs = arrayOfType(varArgType, nArgs - n);
    arraycopy(args, n, varArgs, 0, nArgs - n);
    newArgs[n] = varArgs;
    return newArgs;
  }

  static <A> String joinWithComma(Collection<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 List<String> classNames(Collection l) {
    return getClassNames(l);
  }

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

  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 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 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 <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 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) {
      return null;
    }
  }

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

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

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

  static <A> A pcallF(IF0<A> f) {
    try {
      return f == null ? null : f.get();
    } catch (Throwable __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) {
      return null;
    }
  }

  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> ArrayList<A> litlist(A... a) {
    ArrayList l = new ArrayList(a.length);
    for (A x : a) l.add(x);
    return l;
  }

  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(__20 -> isLetterOrDigit(__20), s);
    else
      return "" + first(s);
  }

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

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

  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 <A, B> Map<A, B> newWeakHashMap() {
    return _registerWeakMap(synchroMap(new WeakHashMap()));
  }

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

  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 Map emptyMap() {
    return new HashMap();
  }

  static Comparator<String> caseInsensitiveComparator() {
    return betterCIComparator();
  }

  static TreeSet<String> caseInsensitiveSet_treeSet() {
    return new TreeSet(caseInsensitiveComparator());
  }

  static TreeSet<String> caseInsensitiveSet_treeSet(Collection<String> c) {
    return toCaseInsensitiveSet_treeSet(c);
  }

  // f: A -> Comparable
  static <A> List<A> sortByCalculatedFieldDesc_inPlace(List<A> l, final Object f) {
    sort(l, new Comparator<A>() {

      public int compare(A b, A a) {
        return stdcompare((Object) callF(f, a), (Object) callF(f, b));
      }
    });
    return l;
  }

  static <A> List<A> sortByCalculatedFieldDesc_inPlace(Object f, List<A> c) {
    return sortByCalculatedFieldDesc_inPlace(c, f);
  }

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

  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 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 Map synchroMap() {
    return synchroHashMap();
  }

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

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

  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) {
      // could optimize this
      return null;
    }
  }

  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 boolean isSubtypeOf(Class a, Class b) {
    // << always hated that method, let's replace it!
    return a != null && b != null && b.isAssignableFrom(a);
  }

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

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

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

  // 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 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 Throwable getExceptionCause(Throwable e) {
    Throwable c = e.getCause();
    return c != null ? c : e;
  }

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

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

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

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

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

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

  static <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 Object callFunction(Object f, Object... args) {
    return callF(f, args);
  }

  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 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 Object pcallFunction(Object f, Object... args) {
    try {
      return callFunction(f, args);
    } catch (Throwable __e) {
      printStackTrace(__e);
    }
    return null;
  }

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

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

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

  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 Byte first(byte[] l) {
    return empty(l) ? null : l[0];
  }

  static int first(IntBuffer buf) {
    return buf.get(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;
  }

  // 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 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 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 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 void assertTrue(Object o) {
    if (!(eq(o, true)))
      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 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 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 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 <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 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;
      // initializer time workaround
      if (callMC_cache == null)
        callMC_cache = new HashMap();
      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();
      }
    }
  }

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

  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 Map synchroHashMap() {
    return synchronizedMap(new HashMap());
  }

  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 <A> HashSet<A> litset(A... items) {
    return lithashset(items);
  }

  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 <A> A[] makeArray(Class<A> type, int n) {
    return (A[]) Array.newInstance(type, n);
  }

  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 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 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 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 <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> 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 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 <A extends Throwable> A printException(A e) {
    printStackTrace(e);
    return e;
  }

  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();
    // must be x30 init
    if (generalMap == null)
      return null;
    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(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);
  }

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

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

  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 Map synchronizedMap() {
    return synchroMap();
  }

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

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

  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 domainIsUnder(String domain, String mainDomain) {
    return eqic(domain, mainDomain) || ewic(domain, "." + mainDomain);
  }

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

  static <A> Set<A> synchroHashSet() {
    return synchronizedSet(new HashSet<A>());
  }

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

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

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

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

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

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

  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 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 boolean regionMatchesIC(String a, int offsetA, String b, int offsetB, int len) {
    return a != null && a.regionMatches(true, offsetA, b, offsetB, len);
  }

  // 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;
      while (_c != null) {
        for (Method m : _c.getDeclaredMethods()) if (!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.
      for (Class intf : allInterfacesImplementedBy(c)) for (Method m : intf.getDeclaredMethods()) if (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);
      }
    }
  }

  static abstract class VF1<A> implements IVF1<A> {

    public abstract void get(A a);
  }

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

    // for matchStart
    String rest() {
      return m[m.length - 1];
    }

    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) {
      // weird signature to prevent accidental calling
      this.text = text;
    }

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

  // goes well with the stage {} macro (see tok_stages)
  static class Stages implements Steppable, Runnable, IFieldsToList {

    static final String _fieldOrder = "stages iStage stage";

    List<Runnable> /*Stage*/
    stages = new ArrayList();

    Stages() {
    }

    Stages(List</*Stage*/
    Runnable> stages) {
      this.stages = stages;
    }

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

    public boolean equals(Object o) {
      if (!(o instanceof Stages))
        return false;
      Stages __1 = (Stages) o;
      return eq(stages, __1.stages);
    }

    public int hashCode() {
      int h = -1808627371;
      h = boostHashCombine(h, _hashCode(stages));
      return h;
    }

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

    int iStage;

    Runnable stage;

    public boolean step() {
      return iStage <= l(stages) && trueBecause(callF(stage = _get(stages, iStage++)));
    }

    void stage(Runnable stage) {
      stages.add(stage);
    }

    void stage(String name, Runnable stage) {
      stages.add(runnableWithCustomToString(name, stage));
    }

    public void run() {
      try {
        stepAll(this);
      } catch (Exception __e) {
        throw rethrow(__e);
      }
    }
  }

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

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

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

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

    Set<A> keys() {
      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 int keyCount() {
      return keysSize();
    }

    int keysSize() {
      synchronized (data) {
        return l(data);
      }
    }

    // full size - note: expensive operation
    final int fullSize() {
      return size();
    }

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

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

  static interface IF0<A> {

    A get();
  }

  static interface Hasher<A> {

    int hashCode(A a);

    boolean equals(A a, A b);
  }

  static interface IF2<A, B, C> {

    C get(A a, B b);
  }

  static interface IF1<A, B> {

    B get(A a);
  }

  /*
 * @(#)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) {
        // never happens
        if (o == null)
          return false;
        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> // unchecked cast
        e = (Map.Entry<K, V>) o;
        Object ev = e.getValue();
        WeakKey wk = WeakKeyCreate(e.getKey());
        Object hv = hash.get(wk);
        if ((hv == null) ? ((ev == null) && hash.containsKey(wk)) : hv.equals(ev)) {
          hash.remove(wk);
          return true;
        }
        return false;
      }

      /*@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 Set<Map.Entry<K, V>> /*@Nullable*/
    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();
    }
  }

  static class PersistableThrowable extends DynamicObject {

    String className;

    String msg;

    String stacktrace;

    PersistableThrowable() {
    }

    PersistableThrowable(Throwable 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;
    }
  }

  static interface IVF1<A> {

    void get(A a);
  }

  // This is using the implementation that seems to work fastest
  // in reality, although it probably is O(n log n) due to the use
  // of TreeMaps.
  // 
  // The theoretically best implementation is O(n) (replacing the
  // TreeMap with a linked list).
  final static class LineCompCompressor {

    int safety = 0;

    abstract static class Chunk {

      abstract String text(List<Chunk> chunks);

      IntPair getPair() {
        return null;
      }
    }

    static class CPair extends Chunk implements IFieldsToList {

      int i1;

      int i2;

      CPair() {
      }

      CPair(int i1, int i2) {
        this.i2 = i2;
        this.i1 = i1;
      }

      public String toString() {
        return shortClassName_dropNumberPrefix(this) + "(" + i1 + ", " + i2 + ")";
      }

      public boolean equals(Object o) {
        if (!(o instanceof CPair))
          return false;
        CPair __3 = (CPair) o;
        return i1 == __3.i1 && i2 == __3.i2;
      }

      public int hashCode() {
        int h = 64355773;
        h = boostHashCombine(h, _hashCode(i1));
        h = boostHashCombine(h, _hashCode(i2));
        return h;
      }

      public Object[] _fieldsToList() {
        return new Object[] { i1, i2 };
      }

      CPair(IntPair p) {
        i1 = p.a;
        i2 = p.b;
      }

      String text(List<Chunk> chunks) {
        return linesLL_rtrim(chunks.get(i1).text(chunks), chunks.get(i2).text(chunks));
      }

      IntPair getPair() {
        return new IntPair(i1, i2);
      }
    }

    static class CPrim extends Chunk implements IFieldsToList {

      String s;

      CPrim() {
      }

      CPrim(String s) {
        this.s = s;
      }

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

      public boolean equals(Object o) {
        if (!(o instanceof CPrim))
          return false;
        CPrim __4 = (CPrim) o;
        return eq(s, __4.s);
      }

      public int hashCode() {
        int h = 64372105;
        h = boostHashCombine(h, _hashCode(s));
        return h;
      }

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

      String text(List<Chunk> chunks) {
        return s;
      }
    }

    boolean verbose = false, verboseCompressionSteps = false;

    boolean verboseStats = false;

    boolean sortLines = true;

    boolean verify = true;

    // compress bytes instead of lines
    boolean byteMode = false;

    // for line mode
    boolean caseInsensitive = false;

    // for byte mode: convert all characters to upper case
    boolean toUpper = false;

    // for "balanced" compression
    boolean recordPairLengths = false;

    // try to lower tree heights by compressing "shorter" pairs first
    boolean balancing = false;

    // keep compressing until every file is a single symbol
    boolean fullCompression = false;

    LineComp_PairIndex pairIndex = new LineComp_PairIndex();

    Map<String, List<String>> textIDToLines;

    List<String> allUniqueLines;

    List<Chunk> chunks = new ArrayList();

    int primChunks;

    Map<String, Integer> lineIndex;

    // temporary
    Map<String, List<Integer>> simpleEncodings;

    Map<String, List<Integer>> finalEncodings;

    // formerly Map<IntPair, Int>
    LongIntHashMap existingPairsIndex = new LongIntHashMap();

    int round, printStatsEvery = /*10000*/
    0, printStatsInFirstRounds = 10;

    // 60 for slower computers
    int printStatsEveryNSeconds = /*10*/
    60;

    // initializing fullIndex = new Map will make things slow and use a lot of memory
    // and I thought there might be a case where it improves the compression
    // - but maybe there isn't?
    Map<String, Integer> fullIndex;

    SimpleIntList pairLengths;

    LineCompCompressor() {
    }

    LineCompCompressor(Map<String, String> texts) {
      loadTexts(texts);
    }

    // key = version ID, values = text
    void loadTexts(Map<String, String> texts) {
      textIDToLines = mapValuesToLinkedHashMap(__35 -> myToLines(__35), texts);
    }

    List<String> myToLines(String s) {
      List<String> l = byteMode ? lambdaMap(__36 -> charToHex(__36), characters(toUpper ? upper(s) : s)) : toLines_nOnly_reversible(s);
      return l;
    }

    String myFromLines(List<String> l) {
      return byteMode ? // TODO: optimize even more
      join(mapI(__37 -> hexToChar(__37), l)) : fromLines_rtrim(l);
    }

    public void run() {
      try {
        if (balancing) {
          recordPairLengths = true;
          pairIndex.pairComparatorForBalancing = (p1, p2) -> {
            int l1 = pairLength(p1), l2 = pairLength(p2);
            if (l1 != l2)
              return l1 - l2;
            // return arbitrary deterministic order, but not 0
            if (p1.a != p2.a)
              return p1.a - p2.a;
            return p1.b - p2.b;
          };
        }
        if (recordPairLengths)
          pairLengths = new SimpleIntList();
        List<String> allLines = concatLists(values(textIDToLines));
        if (verboseCompressionSteps)
          print("Uniquifying " + nLines(allLines));
        allUniqueLines = uniquify(allLines);
        if (verboseCompressionSteps)
          print("Have " + n2(allUniqueLines, "unique line"));
        // allow me to forget
        allLines = null;
        if (sortLines)
          sortInPlace(allUniqueLines);
        if (verboseCompressionSteps)
          print("Sorted " + nLines(allUniqueLines));
        for (String line : allUniqueLines) chunks.add(new CPrim(line));
        primChunks = l(chunks);
        List<String> _lines = collect("s", chunks);
        lineIndex = caseInsensitive ? ciListIndex(_lines) : listIndex(_lines);
        _lines = null;
        // simple encoding (only direct line references)
        simpleEncodings = mapValues(textIDToLines, (IF1<List<String>, List<Integer>>) (lines -> wrapIntArrayAsImmutableList(mapToIntArray(lines, line -> lineIndex.get(line)))));
        // printAndCheckEncodings(simpleEncodings);
        if (verboseCompressionSteps)
          print("Have simple encodings");
        if (!verify)
          textIDToLines = null;
        finalEncodings = compressPairs();
        if (verbose || verify)
          printAndCheckEncodings(finalEncodings);
      } catch (Exception __e) {
        throw rethrow(__e);
      }
    }

    void saveAsTextFile(File f) {
      String out = exportEncoding(finalEncodings);
      saveTextFile(f, out);
      if (verify)
        checkDecompression(f, textIDToLines);
    }

    void checkDecompression(File file, Map<String, List<String>> textIDToLines) {
      BufferedReader reader = bufferedUtf8Reader(file);
      try {
        LineCompReader lcr = new LineCompReader(reader);
        assertEquals(keysList(textIDToLines), asList(lcr.versions()));
        for (String version : keys(textIDToLines)) assertEquals(lcr.textForVersion(version), lines_rtrim(textIDToLines.get(version)));
        if (verbose)
          print("Decompression OK for " + nVersions(textIDToLines));
      } finally {
        _close(reader);
      }
    }

    String asText() {
      return exportEncoding(finalEncodings);
    }

    String exportEncoding(Map<String, List<Integer>> encodings) {
      List<String> buf = new ArrayList();
      // magic signature
      buf.add((byteMode ? "BYTECOMP " : "LINECOMP ") + primChunks);
      for (Chunk c : chunks) {
        if (c instanceof CPair)
          buf.add(((CPair) c).i1 + " " + ((CPair) c).i2);
        else
          buf.add(((CPrim) c).s);
      }
      for (Map.Entry<? extends String, ? extends List<Integer>> __1 : _entrySet(encodings)) {
        String id = __1.getKey();
        List<Integer> l = __1.getValue();
        buf.add(id + "=" + joinWithSpace(l));
      }
      return lines_rtrim(buf);
    }

    Map<String, List<Integer>> compressPairs() {
      pairIndex.verbose = verboseCompressionSteps || verbose;
      pairIndex.init();
      for (Map.Entry<? extends String, ? extends List<Integer>> __5 : _entrySet(simpleEncodings)) {
        String version = __5.getKey();
        List<Integer> l = __5.getValue();
        ping();
        pairIndex.newChain(version, l);
      }
      pairIndex.haveChains();
      // forget
      simpleEncodings = null;
      return compressChains(keys(pairIndex.chains));
    }

    Map<String, List<Integer>> compressChains(Collection<String> files) {
      NotTooOften nto = new NotTooOften(printStatsEveryNSeconds * 1000);
      IntPair toCompress;
      // Compress only most popular pair in one step
      while ((toCompress = fullCompression ? pairIndex.mostPopularPair() : pairIndex.mostPopularDuplicate()) != null) {
        ping();
        if (verbose) {
          print("Chains: " + mapValuesToList(pairIndex.chains, c -> c.toList()));
          // print("Highest bucket (" + pairIndex.highestBucketNr() + "): " + pairIndex.mostPopularDuplicates());
          print("Buckets: " + pairIndex.byCount);
        }
        if (safety > 0 && --safety <= 0)
          throw fail("safety");
        ++round;
        if (verboseStats)
          if (printStatsEvery > 0 && (round % printStatsEvery) == 0 || round <= printStatsInFirstRounds || nto.get())
            printStats();
        int count = pairIndex.getCount(toCompress);
        Integer idx = makeCPair(toCompress);
        int dups = pairIndex.numberOfDuplicates();
        if (verboseCompressionSteps)
          print("Compressing pair " + toCompress + " (count=" + count + ") -> " + idx + ", " + (dups - 1) + " remaining");
        pairIndex.replacePair(toCompress.a, toCompress.b, idx);
      }
      if (verboseStats)
        printStats();
      // reconvert to normal list
      return mapToValues(f -> pairIndex.chains.get(f).toList(), files);
    }

    // TODO: check if pair is already there
    Integer makeCPair(IntPair p) {
      long l = intPairToLong(p);
      String text = null;
      if (fullIndex != null) {
        text = itemToString(p.a) + itemToString(p.b);
        Integer idx = fullIndex.get(text);
        if (idx != null)
          return idx;
      }
      int idx = existingPairsIndex.getIfAbsent(l, -1);
      if (idx < 0) {
        idx = addAndReturnIndex(chunks, new CPair(p));
        if (recordPairLengths)
          listPut(pairLengths, idx, itemLength(p.a) + itemLength(p.b), 1);
        existingPairsIndex.put(l, idx);
        if (fullIndex != null)
          fullIndex.put(text, idx);
      }
      return idx;
    }

    void printAndCheckEncodings(Map<String, List<Integer>> encodings) {
      for (Map.Entry<? extends String, ? extends List<Integer>> __0 : _entrySet(encodings)) {
        String id = __0.getKey();
        List<Integer> encoded = __0.getValue();
        if (verbose)
          print(id + ": " + joinWithSpace(encoded));
        String x = myFromLines(textIDToLines.get(id)), y = decode(encoded);
        if (caseInsensitive)
          assertEqualsIC(x, y);
        else
          assertEquals_quote(x, y);
      }
    }

    String decode(List<Integer> encoded) {
      List<String> l = lambdaMap(__38 -> chunkText(__38), encoded);
      if (byteMode)
        l = lines(lines(l));
      return myFromLines(l);
    }

    // for non-byte mode
    String chunkText(int idx) {
      return chunks.get(idx).text(chunks);
    }

    void printStats() {
      print("Round: " + round);
      pairIndex.printStats();
    }

    // byteMode only
    String itemToString(int idx) {
      StringBuilder buf = new StringBuilder();
      itemToString_step(buf, idx);
      return str(buf);
    }

    void itemToString_step(StringBuilder buf, int idx) {
      Chunk c = chunks.get(idx);
      if (c instanceof CPair) {
        itemToString_step(buf, ((CPair) c).i1);
        itemToString_step(buf, ((CPair) c).i2);
      } else {
        String s = ((CPrim) c).s;
        buf.append(byteMode ? charFromHex(s) : s + "\n");
      }
    }

    int nLiterals() {
      return primChunks;
    }

    int nItems() {
      return l(chunks);
    }

    IntPair getPair(int idx) {
      return chunks.get(idx).getPair();
    }

    int itemLength(int idx) {
      return idx >= l(pairLengths) ? 1 : pairLengths.get(idx);
    }

    int pairLength(IntPair p) {
      return p == null ? 0 : itemLength(p.a) + itemLength(p.b);
    }

    List<String> literals() {
      return lmap(__39 -> itemToString(__39), countIterator(primChunks));
    }
  }

  static interface IVar<A> extends IF0<A> {

    void set(A a);

    A get();

    default boolean has() {
      return get() != null;
    }

    default void clear() {
      set(null);
    }
  }

  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", commaCombine(getCause(), objects));
    }
  }

  static class Pair<A, B> implements Comparable<Pair<A, B>> {

    A a;

    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 IFieldsToList {

    Object[] _fieldsToList();
  }

  final static class LineComp_PairIndex {

    boolean verbose = false;

    // true = use LinkedHashSet for nodes - uses more space but ensures
    // nodes are compacted in order instead of pseudo-randomly
    // (CompactHashSet).
    // When setting this to false, compression is still
    // deterministic since the introduction of the Node.counter
    // field.
    // inOrder = false saves hugely on memory (e.g. 38M instead
    // of 78M for the nodes field for 1M symbols)
    boolean inOrder = false;

    // MultiSetMap<IntPair, Node> nodes;
    // key: pair, value: set of nodes in order (LinkedHashSet)
    LongObjectHashMap<Set<Node>> nodes = new LongObjectHashMap();

    // values are pairs
    MultiSetMap<Integer, IntPair> byCount = // init later
    null;

    // = multiSetMap_innerHashSet_outerRevTreeMap(); // makes a difference in selecting a pair if there are multiple with the same count
    // = multiSetMap_innerCompactHashSet_outerRevTreeMap(); // same but more compact
    // = multiSetMap_innerTreeSet_outerRevTreeMap(); // initial version that kind of pointlessly sorts the same-count nodes lexicographically
    LinkedHashMap<String, Ch> chains = new LinkedHashMap();

    Ch firstChain;

    int totalPairCount;

    int initialNodesSetCapacity = 1;

    List<IVF1<Node>> onAddingPair, onRemovingPair;

    LongIntHashMap existingPairsIndex;

    int nodeCounter;

    // This queue checks all newly made pairs to see if they already
    // have a symbol.
    LinkedList<Node> compressionQueue = new LinkedList();

    // TODO: use LongComparator
    Comparator<IntPair> pairComparatorForBalancing;

    void init() {
    }

    class BalancedByCountMultiSetMap extends MultiSetMap<Integer, IntPair> {

      Set<IntPair> _makeEmptySet() {
        return new BalancedIntPairSet();
      }

      BalancedByCountMultiSetMap() {
        data = revTreeMap();
      }
    }

    class BalancedIntPairSet extends IntPairTreeSet {

      public int compare(long a, long b) {
        return pairComparatorForBalancing.compare(longToIntPair(a), longToIntPair(b));
      }
    }

    // indicate end of chain-making phase.
    // we still accept more chains after this though, I think (for late input)
    void haveChains() {
      if (byCount == null) {
        // time "Making byCount" {
        if (pairComparatorForBalancing != null) {
          // byCount = multiSetMap_innerCustomIntPairTreeSet_outerRevTreeMap(pairComparatorForBalancing);
          byCount = new BalancedByCountMultiSetMap();
        } else
          byCount = multiSetMap_innerCompactHashSet_outerRevTreeMap();
        for (Set<Node> set : nodes.values()) {
          IntPair p = first(set).pair();
          int n = set.size();
          if (verbose)
            print("Adding node " + p + " (" + n + ")");
          byCount.put(n, p);
        }
      // }
      }
    }

    // a "chain" of nodes (one input file)
    static class Ch {

      Node tail;

      Ch(LineComp_PairIndex pi, List<Integer> l) {
        int count = 0;
        for (int i : unnullForIteration(l)) {
          add(pi, i);
          if (((++count) % oneMillion()) == 0)
            print("Added " + n2(count) + " entries to chain");
        }
      }

      List<Integer> toList() {
        List<Integer> l = new ArrayList();
        Node node = tail;
        while (node != null) {
          l.add(node.value);
          node = node.prev;
        }
        return reverseInPlace(l);
      }

      void add(LineComp_PairIndex pi, int i) {
        Node n = new Node();
        n.counter = pi.nodeCounter++;
        n.ch = this;
        n.value = i;
        n.prev = tail;
        if (tail != null)
          tail.next = n;
        tail = n;
        pi.addToIndex(n.prev);
        pi.processQueue();
      }
    }

    static class Node {

      Ch ch;

      // for deterministic ordering in hash set
      int counter;

      int value;

      Node prev, next;

      int a() {
        return value;
      }

      int b() {
        return next == null ? -1 : next.value;
      }

      IntPair pair() {
        return next == null ? null : new IntPair(a(), b());
      }

      public String toString() {
        return stringIf(prev != null, "<") + value + (next == null ? "" : next.value + stringIf(next.next != null, ">"));
      }

      public int hashCode() {
        return counter;
      }
    }

    IntPair nodeToPair(Node n) {
      return n == null ? null : n.pair();
    }

    // add node to pair index
    void addToIndex(Node n) {
      IntPair p = nodeToPair(n);
      if (p == null)
        return;
      callFAll(onAddingPair, n);
      int count = nodes_getSize(p);
      nodes_add(p, n);
      if (byCount != null) {
        // not in init phase
        if (count != 0)
          byCount.remove(count, p);
        byCount.put(count + 1, p);
      }
      if (existingPairsIndex != null)
        compressionQueue.add(n);
    }

    // remove node from pair index
    void removeFromIndex(Node n) {
      IntPair p = nodeToPair(n);
      if (p == null)
        return;
      callFAll(onRemovingPair, n);
      int count = nodes_getSize(p);
      if (count == 0)
        throw fail("Can't remove pair " + p);
      nodes_remove(p, n);
      byCount.remove(count, p);
      if (--count > 0)
        byCount.put(count, p);
    }

    // return all pairs in "most popular" bucket
    Collection<IntPair> mostPopularDuplicates() {
      Integer key = firstKey(byCount);
      return toInt(key) < 2 ? null : byCount.get(key);
    }

    IntPair mostPopularDuplicate() {
      return toInt(firstKey(byCount)) < 2 ? null : firstValue(byCount);
    }

    IntPair mostPopularPair() {
      return firstValue(byCount);
    }

    int highestBucketNr() {
      return or0(firstKey(byCount));
    }

    // counts buckets actually (lower value than totalPairCount)
    int numberOfDuplicates() {
      return byCount.size() - l(byCount.get(1));
    }

    int getCount(IntPair p) {
      return nodes_getSize(p);
    }

    void replacePair(int pa, int pb, int replaceWith) {
      IntPair p = new IntPair(pa, pb);
      Set<Node> set = nodes.get(intPairToLong(p));
      if (set != null)
        for (Node n : cloneList(set)) {
          // nodes might have been deleted or changed
          {
            if (n.a() != pa || n.b() != pb)
              continue;
          }
          replacePair(n, replaceWith);
        }
    }

    void replacePair(Node node, int replaceWith) {
      removeFromIndex(node.prev);
      removeFromIndex(node);
      removeFromIndex(node.next);
      node.value = replaceWith;
      deleteNode(node.next);
      addToIndex(node.prev);
      addToIndex(node);
      processQueue();
    }

    void processQueue() {
      if (existingPairsIndex != null) {
        Node n;
        while ((n = popFirst(compressionQueue)) != null) checkIfPairExists(n);
      }
    }

    void checkIfPairExists(Node node) {
      if (existingPairsIndex == null)
        return;
      if (node.value < 0)
        return;
      IntPair pair = nodeToPair(node);
      if (pair == null)
        return;
      // print("Checking pair " + pair);
      int i = existingPairsIndex.getIfAbsent(intPairToLong(pair), -1);
      if (i >= 0) {
        // print("  Replacing with: " + i);
        replacePair(node, i);
      }
    }

    void deleteNode(Node node) {
      if (node.next != null)
        node.next.prev = node.prev;
      else
        getChain(node).tail = node.prev;
      if (node.prev != null)
        node.prev.next = node.next;
      // mark invalid
      node.value = -1;
    }

    Ch newChain(String version, List<Integer> encoding) {
      Ch ch = new Ch(this, encoding);
      chains.put(version, ch);
      if (firstChain == null)
        firstChain = ch;
      return ch;
    }

    int nodes_getSize(IntPair p) {
      return l(nodes.get(intPairToLong(p)));
    }

    void nodes_add(IntPair p, Node n) {
      ++totalPairCount;
      long l = intPairToLong(p);
      Set<Node> set = nodes.get(l);
      if (set == null)
        nodes.put(l, set = newNodesSet());
      set.add(n);
    }

    Set<Node> newNodesSet() {
      return inOrder ? new LinkedHashSet(initialNodesSetCapacity) : new CompactHashSet(initialNodesSetCapacity);
    }

    void nodes_remove(IntPair p, Node n) {
      --totalPairCount;
      long l = intPairToLong(p);
      Set<Node> set = nodes.get(l);
      if (set == null || !set.remove(n))
        throw fail("Consistency error");
      if (set.isEmpty())
        nodes.remove(l);
    }

    // also shrinks sets...
    void printStats() {
      print("Different pairs: " + l(nodes));
      print("Different counts: " + byCount.keysSize() + " (highest count: " + firstKey(byCount) + ")");
      long count = 0, waste = 0, newWaste = 0;
      long count1 = 0, waste1 = 0;
      for (Set set : nodes.values()) if (set instanceof HashSet) {
        count1 += ((HashSet) set).size();
        int capacity = hashSetCapacity((HashSet) set);
        waste1 += capacity - ((HashSet) set).size();
      // if (capacity > set.size()*3) set.shrink(); // TODO
      }
      if (pairComparatorForBalancing == null)
        for (CompactHashSet set : (Collection<CompactHashSet>) (Collection) values(byCount.data)) {
          count += set.size();
          waste += set.capacity() - set.size();
          set.shrinkToFactor(0.5);
          newWaste += set.capacity() - set.size();
        }
      print("Nodes set count: " + count1 + ". Waste: " + waste1);
      // print("Set count: " + count + ". Waste: " + waste + (waste == newWaste ? "" : " => " + newWaste));
      print("Duplicates: " + n2(totalPairCount - byCount.count(1)));
    }

    Ch getChain(Node node) {
      return node.ch;
    }
    /*public LineComp_PairIndex clone() {
    
  }*/
  }

  static class NotTooOften {

    long minDelay;

    long lastTime;

    NotTooOften() {
    }

    NotTooOften(long minDelay) {
      this.minDelay = minDelay;
    }

    NotTooOften(double minSeconds) {
      minDelay = toMS(minSeconds);
    }

    final boolean yo() {
      return canDoAgain_willDoIfTrue();
    }

    final boolean get() {
      return canDoAgain_willDoIfTrue();
    }

    boolean canDoAgain_willDoIfTrue() {
      ping();
      if (lastTime == 0 || now() >= lastTime + minDelay) {
        lastTime = now();
        return true;
      }
      return false;
    }
  }

  static class LineCompReader {

    List<String> literals = new ArrayList();

    // if not null, don't save pairs, but stream them to onPair instead
    IVF1<Long> onPair;

    // where they start in file
    int[] literalOffsets;

    LongBuffer pairs = new LongBuffer();

    LinkedHashMap<String, List<Integer>> versions = new LinkedHashMap();

    boolean byteMode = false;

    // internal, optional
    CountingInputStream countingInputStream;

    long fileSize;

    LineCompReader() {
    }

    // takes text or gzipped input file
    LineCompReader(File f) {
      load(f);
    }

    LineCompReader(InputStream in) {
      load(rawByteReader(in, 128 * 1024));
    }

    LineCompReader(BufferedReader reader) {
      load(reader);
    }

    void load(File f) {
      fileSize = fileSize(f);
      countingInputStream = new CountingInputStream(bufferedFileInputStream(f));
      BufferedReader reader = isGZipFile(f) ? rawByteReader(gzipInputStream(countingInputStream)) : rawByteReader(countingInputStream);
      try {
        // rawByteReader_possiblyGZipped(f);
        load(reader);
      } finally {
        _close(reader);
      }
    }

    void load(BufferedReader reader) {
      try {
        StringBuilder lineBuf = new StringBuilder();
        String s = readLineIgnoreCR(reader, lineBuf);
        int ofs = l(s) + 1;
        Matches m = new Matches();
        if (startsWith(s, "BYTECOMP ", m))
          byteMode = true;
        else if (!startsWith(s, "LINECOMP ", m))
          throw fail("Not a LINECOMP file");
        int nLiterals = parseInt(m.rest());
        IntBuffer offsets = new IntBuffer();
        for (int i = 0; i < nLiterals; i++) {
          String line = readLineIgnoreCR(reader, lineBuf);
          assertNotNull(line);
          literals.add(byteMode ? str(charFromHex(line)) : line);
          offsets.add(ofs);
          ofs += l(line) + 1;
        }
        offsets.add(ofs);
        literalOffsets = offsets.toArray();
        int n = 0;
        while (licensed()) {
          s = readLineIgnoreCR(reader, lineBuf);
          if (s == null || contains(s, "="))
            break;
          try {
            int iSpace = s.indexOf(' ');
            long pair = twoIntsToLong(Integer.parseInt(s, 0, iSpace, 10), Integer.parseInt(s, iSpace + 1, l(s), 10));
            if (onPair != null)
              onPair.get(pair);
            else
              pairs.add(pair);
            if (((++n) % oneMillion()) == 0) {
              String percentage = "";
              if (fileSize != 0 && countingInputStream != null)
                percentage = " (" + intPercentRatio(countingInputStream.getFilePointer(), fileSize) + "%)";
              print(nPairs(n) + " read" + percentage);
            }
          } catch (Throwable _e) {
            print("On line " + (nLiterals + l(pairs)));
            throw rethrow(_e);
          }
        }
        pairs.trimToSize();
        while (contains(s, "=")) {
          int i = indexOf(s, '=');
          versions.put(takeFirst(s, i), compactIntList(parseInts(splitAtSpace(substring(s, i + 1)))));
          s = readLineIgnoreCR(reader, lineBuf);
        }
      } catch (Exception __e) {
        throw rethrow(__e);
      }
    }

    Set<String> versions() {
      return keys(versions);
    }

    String getText(String version) {
      return textForVersion(version);
    }

    String textForVersion(String version) {
      List<Integer> encoded = versions.get(version);
      if (encoded == null)
        return null;
      List<String> buf = new ArrayList();
      for (int idx : encoded) decode(idx, buf);
      return myFromLines(buf);
    }

    // name of first (or only) file
    String firstFile() {
      return first(versions());
    }

    // text for first (or only) file
    String text() {
      return getText(firstFile());
    }

    List<Integer> encoding() {
      return versions.get(firstFile());
    }

    String myFromLines(List<String> l) {
      return byteMode ? join(l) : fromLines_rtrim(l);
    }

    void decode(int idx, List<String> buf) {
      if (idx < l(literals))
        buf.add(literals.get(idx));
      else {
        long p = pairs.get(idx - l(literals));
        decode(firstIntFromLong(p), buf);
        decode(secondIntFromLong(p), buf);
      }
    }

    // That was it! The rest of this file is just for calculating some stats.
    Map<Integer, Integer> lineCountsForPairs = new HashMap();

    Map<Integer, Long> byteCountsForPairs = new HashMap();

    int lineCountForPointer(int idx) {
      return idx < l(literals) ? 1 : lineCountForPair(idx);
    }

    long byteCountForPointer(int idx) {
      return idx < l(literals) ? l(literals.get(idx)) + 1 : byteCountForPair(idx);
    }

    int lineCountForPair(int idx) {
      Integer c = lineCountsForPairs.get(idx);
      if (c == null) {
        long p = pairs.get(idx - l(literals));
        c = lineCountForPointer(firstIntFromLong(p)) + lineCountForPointer(secondIntFromLong(p));
        lineCountsForPairs.put(idx, c);
      }
      return c;
    }

    long byteCountForPair(int idx) {
      Long c = byteCountsForPairs.get(idx);
      if (c == null) {
        long p = pairs.get(idx - l(literals));
        c = byteCountForPointer(firstIntFromLong(p)) + byteCountForPointer(secondIntFromLong(p));
        byteCountsForPairs.put(idx, c);
      }
      return c;
    }

    int lineCountForVersion(String version) {
      List<Integer> encoded = versions.get(version);
      if (encoded == null)
        return 0;
      int n = 0;
      for (int i : encoded) n += lineCountForPointer(i);
      return n;
    }

    long byteCountForVersion(String version) {
      List<Integer> encoded = versions.get(version);
      if (encoded == null)
        return 0;
      long n = 0;
      for (int i : encoded) n += byteCountForPointer(i);
      return max(0, n - 1);
    }

    long totalByteCount() {
      return longSum(lambdaMap(__40 -> byteCountForVersion(__40), versions()));
    }

    // now we can also save again
    void save(PrintWriter out) {
      out.println((byteMode ? "BYTECOMP " : "LINECOMP ") + l(literals));
      for (String s : literals) out.println(byteMode ? charToHex(first(s)) : s);
      for (long p : pairs) out.println(firstIntFromLong(p) + " " + secondIntFromLong(p));
      for (Map.Entry<? extends String, ? extends List<Integer>> __0 : _entrySet(versions)) {
        String id = __0.getKey();
        List<Integer> l = __0.getValue();
        out.println(id + "=" + joinWithSpace(l));
      }
    }
  }

  static interface IAutoCloseableF0<A> extends IF0<A>, AutoCloseable {
  }

  static class Stage implements Runnable {

    String name;

    boolean done = false;

    Object result;

    PersistableThrowable error;

    // long started, done; // timestamps
    // S log;
    IF0 code;

    static String _fieldOrder = "name done result";

    Stage() {
    }

    Stage(String name) {
      this.name = name;
    }

    Stage(String name, IF0 code) {
      this.code = code;
      this.name = name;
    }

    transient List<Runnable> onComputed;

    Stage onComputed(Runnable r) {
      onComputed = syncAddOrCreate(onComputed, r);
      return this;
    }

    void computed() {
      pcallFAll(onComputed);
    }

    public void run() {
      try {
        if (done || code == null)
          return;
        try {
          result = code.get();
          computed();
        } catch (Throwable e) {
          printStackTrace(e);
          error = persistableThrowable(e);
        } finally {
          done = true;
        }
      } catch (Exception __e) {
        throw rethrow(__e);
      }
    }
  }

  static interface Steppable {

    // return false if done
    public boolean step();
  }

  static class SimpleIntList extends RandomAccessAbstractList<Integer> {

    int[] data = EMPTY_ELEMENTDATA;

    int size;

    private static final int[] EMPTY_ELEMENTDATA = {};

    public void add(int i) {
      ensureCapacityInternal(size + 1);
      data[size++] = i;
    }

    public boolean add(Integer i) {
      add((int) i);
      return true;
    }

    public Integer set(int i, Integer value) {
      if (i >= size)
        throw fail("Index out of range: " + i);
      int old = data[i];
      data[i] = value;
      return old;
    }

    public int size() {
      return size;
    }

    public Integer get(int i) {
      if (i >= 0 && i < size)
        return data[i];
      throw new IndexOutOfBoundsException(i + "/" + size);
    }

    void ensureCapacityInternal(int minCapacity) {
      if (data.length < minCapacity)
        grow(minCapacity);
    }

    private void grow(int minCapacity) {
      int oldCapacity = data.length;
      int newCapacity = oldCapacity + (oldCapacity >> 1);
      if (newCapacity - minCapacity < 0)
        newCapacity = minCapacity;
      data = Arrays.copyOf(data, newCapacity);
    }

    // always returns a fresh copy
    int[] toIntArray() {
      int[] a = new int[size];
      System.arraycopy(data, 0, a, 0, size);
      return a;
    }
  }

  static final class IntPair implements Comparable<IntPair>, IFieldsToList {

    int a;

    int b;

    IntPair() {
    }

    IntPair(int a, int b) {
      this.b = b;
      this.a = a;
    }

    public String toString() {
      return shortClassName_dropNumberPrefix(this) + "(" + a + ", " + b + ")";
    }

    public Object[] _fieldsToList() {
      return new Object[] { a, b };
    }

    public boolean equals(Object o) {
      if (!(o instanceof IntPair))
        return false;
      IntPair x = (IntPair) o;
      return a == x.a && b == x.b;
    }

    public int hashCode() {
      int h = -672893111;
      h = boostHashCombine(h, _hashCode(a));
      h = boostHashCombine(h, _hashCode(b));
      return h;
    }

    public int compareTo(IntPair p) {
      if (p == null)
        return 1;
      int pa = p.a;
      if (a < pa)
        return -1;
      if (a > pa)
        return 1;
      return Integer.compare(b, p.b);
    }
  }

  static class LongBuffer implements Iterable<Long>, ILongQueue {

    long[] data;

    int size;

    LongBuffer() {
    }

    LongBuffer(int size) {
      if (size != 0)
        data = new long[size];
    }

    LongBuffer(Iterable<Long> l) {
      this(l(l));
      addAll(l);
    }

    public void add(long i) {
      if (size >= lLongArray(data)) {
        data = resizeLongArray(data, Math.max(1, toInt(Math.min(maximumSafeArraySize(), lLongArray(data) * 2L))));
        if (size >= data.length)
          throw fail("LongBuffer too large: " + size);
      }
      data[size++] = i;
    }

    void addAll(Iterable<Long> l) {
      if (l != null)
        for (long i : l) add(i);
    }

    long[] toArray() {
      return size == 0 ? null : resizeLongArray(data, size);
    }

    List<Long> toList() {
      return longArrayToList(data, 0, size);
    }

    List<Long> asVirtualList() {
      return listFromFunction(__41 -> get(__41), size);
    }

    void reset() {
      size = 0;
    }

    void clear() {
      reset();
    }

    int size() {
      return size;
    }

    public boolean isEmpty() {
      return size == 0;
    }

    long get(int idx) {
      if (idx >= size)
        throw fail("Index out of range: " + idx + "/" + size);
      return data[idx];
    }

    void set(int idx, long value) {
      if (idx >= size)
        throw fail("Index out of range: " + idx + "/" + size);
      data[idx] = value;
    }

    long popLast() {
      if (size == 0)
        throw fail("empty buffer");
      return data[--size];
    }

    long last() {
      return data[size - 1];
    }

    long nextToLast() {
      return data[size - 2];
    }

    public String toString() {
      return squareBracket(joinWithSpace(toList()));
    }

    public Iterator<Long> iterator() {
      return new IterableIterator<Long>() {

        int i = 0;

        public boolean hasNext() {
          return i < size;
        }

        public Long next() {
          if (!hasNext())
            throw fail("Index out of bounds: " + i);
          return data[i++];
        }
      };
    }

    void trimToSize() {
      data = resizeLongArray(data, size);
    }

    // don't rely on return value if buffer is empty
    public long poll() {
      return size == 0 ? -1 : data[--size];
    }
  }

  // based on: https://algs4.cs.princeton.edu/33balanced/RedBlackBST.java.html
  static class IntPairTreeSet extends AbstractSet<IntPair> {

    private static final boolean RED = true;

    private static final boolean BLACK = false;

    // root of the BST
    private Node root;

    // size of tree set
    int size;

    // BST helper node data type
    private static class Node {

      // associated data
      private long val;

      // links to left and right subtrees
      private Node left, right;

      // color of parent link
      private boolean color = false;

      public Node(long val, boolean color) {
        this.val = val;
        this.color = color;
      }
    }

    IntPairTreeSet() {
    }

    IntPairTreeSet(Collection<IntPair> cl) {
      addAll(cl);
    }

    // is node x red; false if x is null ?
    private boolean isRed(Node x) {
      if (x == null)
        return false;
      return x.color == RED;
    }

    public int size() {
      return size;
    }

    public boolean isEmpty() {
      return root == null;
    }

    @Override
    public boolean add(IntPair val) {
      return add(intPairToLong(val));
    }

    public boolean add(long val) {
      int oldSize = size;
      root = put(root, val);
      root.color = BLACK;
      return size > oldSize;
    }

    // insert the value in the subtree rooted at h
    private Node put(Node h, long val) {
      if (h == null) {
        ++size;
        return new Node(val, RED);
      }
      int cmp = compare(val, h.val);
      if (cmp < 0)
        h.left = put(h.left, val);
      else if (cmp > 0)
        h.right = put(h.right, val);
      else // no overwriting
      {
      /*h.val = val;*/
      }
      // fix-up any right-leaning links
      if (isRed(h.right) && !isRed(h.left))
        h = rotateLeft(h);
      if (isRed(h.left) && isRed(h.left.left))
        h = rotateRight(h);
      if (isRed(h.left) && isRed(h.right))
        flipColors(h);
      return h;
    }

    // override if you want custom sorting
    int compare(long a, long b) {
      return cmp(a, b);
    }

    @Override
    public boolean remove(Object key) {
      return remove(intPairToLong((IntPair) key));
    }

    public boolean remove(long key) {
      if (!contains(key))
        return false;
      // if both children of root are black, set root to red
      if (!isRed(root.left) && !isRed(root.right))
        root.color = RED;
      root = delete(root, key);
      if (!isEmpty())
        root.color = BLACK;
      // assert check();
      return true;
    }

    // delete the key-value pair with the given key rooted at h
    private Node delete(Node h, long key) {
      // assert get(h, key) != null;
      if (compare(key, h.val) < 0) {
        if (!isRed(h.left) && !isRed(h.left.left))
          h = moveRedLeft(h);
        h.left = delete(h.left, key);
      } else {
        if (isRed(h.left))
          h = rotateRight(h);
        if (compare(key, h.val) == 0 && (h.right == null)) {
          --size;
          return null;
        }
        if (!isRed(h.right) && !isRed(h.right.left))
          h = moveRedRight(h);
        if (compare(key, h.val) == 0) {
          --size;
          Node x = min(h.right);
          h.val = x.val;
          // h.val = get(h.right, min(h.right).val);
          // h.val = min(h.right).val;
          h.right = deleteMin(h.right);
        } else
          h.right = delete(h.right, key);
      }
      return balance(h);
    }

    // make a left-leaning link lean to the right
    private Node rotateRight(Node h) {
      // assert (h != null) && isRed(h.left);
      Node x = h.left;
      h.left = x.right;
      x.right = h;
      x.color = x.right.color;
      x.right.color = RED;
      return x;
    }

    // make a right-leaning link lean to the left
    private Node rotateLeft(Node h) {
      // assert (h != null) && isRed(h.right);
      Node x = h.right;
      h.right = x.left;
      x.left = h;
      x.color = x.left.color;
      x.left.color = RED;
      return x;
    }

    // flip the colors of a node and its two children
    private void flipColors(Node h) {
      // h must have opposite color of its two children
      // assert (h != null) && (h.left != null) && (h.right != null);
      // assert (!isRed(h) &&  isRed(h.left) &&  isRed(h.right))
      // || (isRed(h)  && !isRed(h.left) && !isRed(h.right));
      h.color = !h.color;
      h.left.color = !h.left.color;
      h.right.color = !h.right.color;
    }

    // Assuming that h is red and both h.left and h.left.left
    // are black, make h.left or one of its children red.
    private Node moveRedLeft(Node h) {
      // assert (h != null);
      // assert isRed(h) && !isRed(h.left) && !isRed(h.left.left);
      flipColors(h);
      if (isRed(h.right.left)) {
        h.right = rotateRight(h.right);
        h = rotateLeft(h);
        flipColors(h);
      }
      return h;
    }

    // Assuming that h is red and both h.right and h.right.left
    // are black, make h.right or one of its children red.
    private Node moveRedRight(Node h) {
      // assert (h != null);
      // assert isRed(h) && !isRed(h.right) && !isRed(h.right.left);
      flipColors(h);
      if (isRed(h.left.left)) {
        h = rotateRight(h);
        flipColors(h);
      }
      return h;
    }

    // restore red-black tree invariant
    private Node balance(Node h) {
      // assert (h != null);
      if (isRed(h.right))
        h = rotateLeft(h);
      if (isRed(h.left) && isRed(h.left.left))
        h = rotateRight(h);
      if (isRed(h.left) && isRed(h.right))
        flipColors(h);
      return h;
    }

    /**
     * Returns the height of the BST (for debugging).
     * @return the height of the BST (a 1-node tree has height 0)
     */
    public int height() {
      return height(root);
    }

    private int height(Node x) {
      if (x == null)
        return -1;
      return 1 + Math.max(height(x.left), height(x.right));
    }

    @Override
    public boolean contains(Object val) {
      return contains(intPairToLong((IntPair) val));
    }

    public boolean contains(long val) {
      return find(root, val) != null;
    }

    Node find(Node x, long key) {
      while (x != null) {
        int cmp = compare(key, x.val);
        if (cmp < 0)
          x = x.left;
        else if (cmp > 0)
          x = x.right;
        else
          return x;
      }
      return null;
    }

    private boolean check() {
      if (!is23())
        println("Not a 2-3 tree");
      if (!isBalanced())
        println("Not balanced");
      return is23() && isBalanced();
    }

    // Does the tree have no red right links, and at most one (left)
    // red links in a row on any path?
    private boolean is23() {
      return is23(root);
    }

    private boolean is23(Node x) {
      if (x == null)
        return true;
      if (isRed(x.right))
        return false;
      if (x != root && isRed(x) && isRed(x.left))
        return false;
      return is23(x.left) && is23(x.right);
    }

    // do all paths from root to leaf have same number of black edges?
    private boolean isBalanced() {
      // number of black links on path from root to min
      int black = 0;
      Node x = root;
      while (x != null) {
        if (!isRed(x))
          black++;
        x = x.left;
      }
      return isBalanced(root, black);
    }

    // does every path from the root to a leaf have the given number of black links?
    private boolean isBalanced(Node x, int black) {
      if (x == null)
        return black == 0;
      if (!isRed(x))
        black--;
      return isBalanced(x.left, black) && isBalanced(x.right, black);
    }

    public void clear() {
      root = null;
      size = 0;
    }

    // the smallest key in subtree rooted at x; null if no such key
    private Node min(Node x) {
      // assert x != null;
      while (x.left != null) x = x.left;
      return x;
    }

    private Node deleteMin(Node h) {
      if (h.left == null)
        return null;
      if (!isRed(h.left) && !isRed(h.left.left))
        h = moveRedLeft(h);
      h.left = deleteMin(h.left);
      return balance(h);
    }

    public Iterator<IntPair> iterator() {
      return new MyIterator();
    }

    class MyIterator extends IterableIterator<IntPair> {

      List<Node> path = new ArrayList();

      MyIterator() {
        fetch(root);
      }

      void fetch(Node node) {
        while (node != null) {
          path.add(node);
          node = node.left;
        }
      }

      public boolean hasNext() {
        return !path.isEmpty();
      }

      public IntPair next() {
        if (path.isEmpty())
          throw fail("no more elements");
        Node node = popLast(path);
        // last node is always a leaf, so left is null
        // so proceed to fetch right branch
        fetch(node.right);
        return longToIntPair(node.val);
      }
    }

    // Returns the smallest key in the symbol table greater than or equal to {@code key}.
    public IntPair ceiling(long key) {
      Node x = ceiling(root, key);
      return x == null ? null : longToIntPair(x.val);
    }

    // the smallest key in the subtree rooted at x greater than or equal to the given key
    Node ceiling(Node x, long key) {
      if (x == null)
        return null;
      int cmp = compare(key, x.val);
      if (cmp == 0)
        return x;
      if (cmp > 0)
        return ceiling(x.right, key);
      Node t = ceiling(x.left, key);
      if (t != null)
        return t;
      else
        return x;
    }

    public IntPair floor(long key) {
      Node x = floor(root, key);
      return x == null ? null : longToIntPair(x.val);
    }

    // the largest key in the subtree rooted at x less than or equal to the given key
    Node floor(Node x, long key) {
      if (x == null)
        return null;
      int cmp = compare(key, x.val);
      if (cmp == 0)
        return x;
      if (cmp < 0)
        return floor(x.left, key);
      Node t = floor(x.right, key);
      if (t != null)
        return t;
      else
        return x;
    }
  }

  // uses hash sets as inner sets unless subclassed
  // uses a hash map as the outer map by default
  static class MultiSetMap<A, B> {

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

    // number of values
    int size;

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

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

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

    Set<A> keys() {
      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());
      }
    }

    int keysSize() {
      synchronized (data) {
        return l(data);
      }
    }

    // full size
    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);
      }
    }

    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 IntBuffer implements Iterable<Integer> {

    int[] data;

    int size;

    IntBuffer() {
    }

    IntBuffer(int size) {
      if (size != 0)
        data = new int[size];
    }

    IntBuffer(Iterable<Integer> l) {
      this(l(l));
      addAll(l);
    }

    void add(int i) {
      if (size >= lIntArray(data)) {
        data = resizeIntArray(data, Math.max(1, toInt(Math.min(maximumSafeArraySize(), lIntArray(data) * 2L))));
        if (size >= data.length)
          throw fail("IntBuffer too large: " + size);
      }
      data[size++] = i;
    }

    void addAll(Iterable<Integer> l) {
      if (l != null)
        for (int i : l) add(i);
    }

    int[] toArray() {
      return size == 0 ? null : resizeIntArray(data, size);
    }

    List<Integer> toList() {
      return intArrayToList(data, 0, size);
    }

    List<Integer> asVirtualList() {
      return new RandomAccessAbstractList<Integer>() {

        public int size() {
          return size;
        }

        public Integer get(int i) {
          return IntBuffer.this.get(i);
        }

        public Integer set(int i, Integer val) {
          Integer a = get(i);
          data[i] = val;
          return a;
        }
      };
    }

    void reset() {
      size = 0;
    }

    void clear() {
      reset();
    }

    int size() {
      return size;
    }

    boolean isEmpty() {
      return size == 0;
    }

    int get(int idx) {
      if (idx >= size)
        throw fail("Index out of range: " + idx + "/" + size);
      return data[idx];
    }

    void set(int idx, int value) {
      if (idx >= size)
        throw fail("Index out of range: " + idx + "/" + size);
      data[idx] = value;
    }

    int popLast() {
      if (size == 0)
        throw fail("empty buffer");
      return data[--size];
    }

    int last() {
      return data[size - 1];
    }

    int nextToLast() {
      return data[size - 2];
    }

    public String toString() {
      return squareBracket(joinWithSpace(toList()));
    }

    public Iterator<Integer> iterator() {
      return new IterableIterator<Integer>() {

        int i = 0;

        public boolean hasNext() {
          return i < size;
        }

        public Integer next() {
          // if (!hasNext()) fail("Index out of bounds: " + i);
          return data[i++];
        }
      };
    }

    public IntegerIterator integerIterator() {
      return new IntegerIterator() {

        int i = 0;

        public boolean hasNext() {
          return i < size;
        }

        public int next() {
          // if (!hasNext()) fail("Index out of bounds: " + i);
          return data[i++];
        }

        public String toString() {
          return "Iterator@" + i + " over " + IntBuffer.this;
        }
      };
    }

    void trimToSize() {
      data = resizeIntArray(data, size);
    }
  }

  static class CountingInputStream extends FilterInputStream {

    long counter;

    CountingInputStream(InputStream in) {
      super(in);
    }

    @Override
    public int read() throws IOException {
      int c = in.read();
      if (c >= 0)
        ++counter;
      return c;
    }

    @Override
    public int read(byte[] b) throws IOException {
      int n = in.read(b);
      counter += max(n, 0);
      return n;
    }

    @Override
    public int read(byte[] b, int off, int len) throws IOException {
      int n = in.read(b, off, len);
      counter += max(n, 0);
      return n;
    }

    long getFilePointer() {
      return counter;
    }
  }

  abstract static class RandomAccessAbstractList<A> extends AbstractList<A> implements RandomAccess {
  }

  /*
 * #!
 * 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.
  static class CompactHashSet<A> extends java.util.AbstractSet<A> {

    protected final static int INITIAL_SIZE = 0;

    // 2 or 3 are useful
    protected final static int FIRST_INCREMENT = 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;

    CompactHashSet() {
      this(INITIAL_SIZE);
    }

    CompactHashSet(int size) {
      objects = (A[]) (size == 0 ? emptyObjectArray() : new Object[size]);
      elements = 0;
      freecells = objects.length;
    }

    CompactHashSet(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;
    }

    synchronized A find(Object o) {
      if (objects.length == 0)
        return null;
      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
    synchronized public boolean add(Object o) {
      if (objects.length == 0)
        rehash(FIRST_INCREMENT);
      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 (// reusing a deleted cell
        deletedix != -1)
          index = deletedix;
        else
          freecells--;
        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
    synchronized public boolean remove(Object o) {
      if (objects.length == 0)
        return false;
      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;
        elements--;
        return true;
      } else
        // we did not find the object
        return false;
    }

    @Override
    synchronized public void clear() {
      elements = 0;
      for (int ix = 0; ix < objects.length; ix++) objects[ix] = null;
      freecells = objects.length;
    }

    @Override
    synchronized 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
    synchronized 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;

      @SuppressWarnings("empty-statement")
      public CompactHashIterator() {
        synchronized (CompactHashSet.this) {
          for (index = 0; index < objects.length && (objects[index] == null || objects[index] == deletedObject); index++) ;
        }
      }

      @Override
      public boolean hasNext() {
        synchronized (CompactHashSet.this) {
          return index < objects.length;
        }
      }

      @SuppressWarnings("empty-statement")
      @Override
      public T next() {
        synchronized (CompactHashSet.this) {
          /*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() {
        synchronized (CompactHashSet.this) {
          if (lastReturned == -1 || lastReturned == -2)
            throw new IllegalStateException();
          // delete object
          if (objects[lastReturned] != null && objects[lastReturned] != deletedObject) {
            objects[lastReturned] = (A) deletedObject;
            elements--;
          }
        }
      }
    }

    synchronized int capacity() {
      return objects.length;
    }

    // returns true if there was a shrink
    synchronized 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;
    }
  }

  abstract static class IntegerIterator {

    abstract boolean hasNext();

    abstract int next();
  }

  static interface ILongQueue {

    public boolean isEmpty();

    public void add(long element);

    // return value is undefined if queue is empty
    public long poll();
  }

  static boolean isAbstract(Class c) {
    return (c.getModifiers() & Modifier.ABSTRACT) != 0;
  }

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

  static boolean reflection_isForbiddenMethod(Method m) {
    return m.getDeclaringClass() == Object.class && eqOneOf(m.getName(), "finalize", "clone", "registerNatives");
  }

  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 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 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 unquote(String s) {
    if (s == null)
      return null;
    if (startsWith(s, '[')) {
      int i = 1;
      while (i < s.length() && s.charAt(i) == '=') ++i;
      if (i < s.length() && s.charAt(i) == '[') {
        String m = s.substring(1, i);
        if (s.endsWith("]" + m + "]"))
          return s.substring(i + 1, s.length() - i - 1);
      }
    }
    if (s.length() > 1) {
      char c = s.charAt(0);
      if (c == '\"' || c == '\'') {
        int l = endsWith(s, c) ? s.length() - 1 : s.length();
        StringBuilder sb = new StringBuilder(l - 1);
        for (int i = 1; i < l; i++) {
          char ch = s.charAt(i);
          if (ch == '\\') {
            char nextChar = (i == l - 1) ? '\\' : s.charAt(i + 1);
            // 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:
                // added by Stefan
                ch = nextChar;
            }
            i++;
          }
          sb.append(ch);
        }
        return sb.toString();
      }
    }
    // not quoted - return original
    return s;
  }

  static List<String> quoteAll(Collection<String> l) {
    List<String> x = new ArrayList();
    for (String s : l) x.add(quote(s));
    return x;
  }

  static int _hashCode(Object a) {
    return a == null ? 0 : a.hashCode();
  }

  static <A> ArrayList<A> toList(A[] a) {
    return asList(a);
  }

  static ArrayList<Integer> toList(int[] 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 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 String shortClassName_dropNumberPrefix(Object o) {
    return dropNumberPrefix(shortClassName(o));
  }

  static int boostHashCombine(int a, int b) {
    return a ^ (b + 0x9e3779b9 + (a << 6) + (a >> 2));
  }

  static boolean trueBecause(Object something) {
    return true;
  }

  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 Runnable runnableWithCustomToString(String s, Runnable r) {
    if (r == null)
      return null;
    return new Runnable() {

      public void run() {
        try {
          r.run();
        } catch (Exception __e) {
          throw rethrow(__e);
        }
      }

      public String toString() {
        return unnull(s);
      }
    };
  }

  static void stepAll(Steppable s) {
    if (s != null)
      while (s.step()) {
        ping();
      }
  }

  static Object metaGet(IMeta o, Object key) {
    return metaMapGet(o, key);
  }

  static Object metaGet(Object o, Object key) {
    return metaMapGet(o, key);
  }

  static Object metaMapGet(IMeta o, Object key) {
    // We now let the object itself do it (overridable!)
    return o == null ? null : o.metaGet(key);
  }

  static Object metaMapGet(Object o, Object key) {
    if (o instanceof IMeta)
      return metaMapGet(((IMeta) o), key);
    return null;
  }

  static Map convertObjectMetaToMap(IMeta o) {
    return convertObjectMetaToMap(o, () -> synchroLinkedHashMap());
  }

  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 <A> Iterator<A> iterator(Iterable<A> c) {
    return c == null ? emptyIterator() : c.iterator();
  }

  static UnsupportedOperationException unsupportedOperation() {
    throw new UnsupportedOperationException();
  }

  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 <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 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, 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 <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 // copies comparator
      map instanceof TreeMap ? // copies comparator
      new TreeMap((TreeMap) map) : 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;
  }

  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 linesLL_rtrim(Object... x) {
    return lines_rtrim(ll(x));
  }

  static LinkedHashMap mapValuesToLinkedHashMap(Object func, Map map) {
    LinkedHashMap m = new LinkedHashMap();
    for (Object key : keys(map)) m.put(key, callF(func, map.get(key)));
    return m;
  }

  static <A, B, C> LinkedHashMap<A, C> mapValuesToLinkedHashMap(Map<A, B> map, IF1<B, C> f) {
    return mapValuesToLinkedHashMap(f, map);
  }

  static <A, B, C> LinkedHashMap<A, C> mapValuesToLinkedHashMap(IF1<B, C> f, Map<A, B> map) {
    return mapValuesToLinkedHashMap((Object) f, map);
  }

  static LinkedHashMap mapValuesToLinkedHashMap(Map map, Object func) {
    return mapValuesToLinkedHashMap(func, map);
  }

  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 String charToHex(char c) {
    return bytesToHex(charToBytes(c));
  }

  static List<Character> characters(final String s) {
    return stringAsCharacterList(s);
  }

  static String upper(String s) {
    return s == null ? null : s.toUpperCase();
  }

  static char upper(char c) {
    return Character.toUpperCase(c);
  }

  static List<String> toLines_nOnly_reversible(String s) {
    List<String> lines = new ArrayList();
    if (s == null)
      return lines;
    int start = 0, n = s.length();
    if (n != 0)
      while (true) {
        int i = smartIndexOf(s, '\n', start);
        lines.add(s.substring(start, i));
        if (i == n)
          break;
        start = i + 1;
      }
    return lines;
  }

  static class mapI_It extends IterableIterator {

    Object f;

    Iterator i;

    mapI_It() {
    }

    mapI_It(Object f, Iterator i) {
      this.i = i;
      this.f = f;
    }

    public boolean hasNext() {
      return i.hasNext();
    }

    public Object next() {
      return callF(f, i.next());
    }

    public String toString() {
      return formatFunctionCall("mapI", f, i);
    }
  }

  // apply a function to an iterator
  static IterableIterator mapI(final Object f, final Iterator i) {
    return new mapI_It(f, i);
  }

  static IterableIterator mapI(IterableIterator i, Object f) {
    return mapI((Iterator) i, f);
  }

  static IterableIterator mapI(Object f, IterableIterator i) {
    return mapI((Iterator) i, f);
  }

  static IterableIterator mapI(Iterator i, Object f) {
    return mapI(f, i);
  }

  static <A, B> IterableIterator<B> mapI(Iterable<A> i, IF1<A, B> f) {
    return mapI(i, (Object) f);
  }

  static <A, B> IterableIterator<B> mapI(Iterator<A> i, IF1<A, B> f) {
    return mapI(f, i);
  }

  static <A, B> IterableIterator<B> mapI(IterableIterator<A> i, IF1<A, B> f) {
    return mapI((Iterator<A>) i, f);
  }

  static <A, B> IterableIterator<B> mapI(IF1<A, B> f, Iterable<A> i) {
    return mapI(i, (Object) f);
  }

  static IterableIterator mapI(Iterable i, Object f) {
    return mapI(f, i.iterator());
  }

  static IterableIterator mapI(Object f, Iterable i) {
    return mapI(i, f);
  }

  static char hexToChar(String s) {
    return charFromHex(s);
  }

  static String fromLines_rtrim(Collection lines) {
    return rtrim_fromLines(lines);
  }

  static String nLines(long n) {
    return n2(n, "line");
  }

  static String nLines(Collection l) {
    return nLines(l(l));
  }

  static String nLines(String s) {
    return nLines(countLines(s));
  }

  static <A> List<A> uniquify(Collection<A> l) {
    return uniquifyList(l);
  }

  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(double l, String singular) {
    return empty(singular) ? str(l) : n2(l, singular, singular + "s");
  }

  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, singular + "s");
  }

  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 <A> List<A> sortInPlace(List<A> l, final Object comparator) {
    return sortedInPlace(l, comparator);
  }

  static <A> List<A> sortInPlace(List<A> l) {
    return sortedInPlace(l);
  }

  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 Map<String, Integer> ciListIndex(List<String> l) {
    return listIndexCI(l);
  }

  static <A> Map<A, Integer> listIndex(List<A> l) {
    Map<A, Integer> map = new HashMap();
    for (int i = 0; i < l(l); i++) map.put(l.get(i), i);
    return map;
  }

  static List<Integer> wrapIntArrayAsImmutableList(int[] l) {
    return new RandomAccessAbstractList<Integer>() {

      public int size() {
        return l.length;
      }

      public Integer get(int i) {
        return l[i];
      }
    };
  }

  static int[] mapToIntArray(Object f, Collection l) {
    return toIntArray(map(f, l));
  }

  static int[] mapToIntArray(Object f, Object[] l) {
    return toIntArray(map(f, l));
  }

  static <A> int[] mapToIntArray(Collection<A> l, IF1<A, Integer> f) {
    return mapToIntArray((Object) f, l);
  }

  /**
   * writes safely (to temp file, then rename)
   */
  static File saveTextFile(String fileName, String contents) throws IOException {
    CriticalAction action = beginCriticalAction("Saving file " + fileName + " (" + l(contents) + " chars)");
    try {
      File file = new File(fileName);
      mkdirsForFile(file);
      String tempFileName = fileName + "_temp";
      File tempFile = new File(tempFileName);
      if (contents != null) {
        if (tempFile.exists())
          try {
            String saveName = tempFileName + ".saved." + now();
            copyFile(tempFile, new File(saveName));
          } catch (Throwable e) {
            printStackTrace(e);
          }
        FileOutputStream fileOutputStream = newFileOutputStream(tempFile.getPath());
        OutputStreamWriter outputStreamWriter = new OutputStreamWriter(fileOutputStream, "UTF-8");
        PrintWriter printWriter = new PrintWriter(outputStreamWriter);
        printWriter.print(contents);
        printWriter.close();
      }
      if (file.exists() && !file.delete())
        throw new IOException("Can't delete " + fileName);
      if (contents != null)
        if (!tempFile.renameTo(file))
          throw new IOException("Can't rename " + tempFile + " to " + file);
      vmBus_send("wroteFile", file);
      return file;
    } finally {
      action.done();
    }
  }

  static File saveTextFile(File fileName, String contents) {
    try {
      saveTextFile(fileName.getPath(), contents);
      return fileName;
    } catch (Exception __e) {
      throw rethrow(__e);
    }
  }

  static BufferedReader bufferedUtf8Reader(InputStream in) {
    return utf8BufferedReader(in);
  }

  static BufferedReader bufferedUtf8Reader(File f) {
    return utf8BufferedReader(f);
  }

  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 <A, B> List<A> keysList(Map<A, B> map) {
    return cloneListSynchronizingOn(keys(map), map);
  }

  static String lines_rtrim(Collection lines) {
    return rtrim_fromLines(lines);
  }

  static String nVersions(long n) {
    return n2(n, "version");
  }

  static String nVersions(Collection l) {
    return nVersions(l(l));
  }

  static String nVersions(Map map) {
    return nVersions(l(map));
  }

  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 List mapValuesToList(Object func, Map map) {
    List out = emptyList(l(map));
    for (Object key : keys(map)) out.add(callF(func, map.get(key)));
    return out;
  }

  static <A, B, C> List<C> mapValuesToList(IF1<B, C> f, Map<A, B> map) {
    return mapValuesToList((Object) f, map);
  }

  static <A, B, C> List<C> mapValuesToList(Map<A, B> map, IF1<B, C> f) {
    return mapValuesToList(f, map);
  }

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

  static Map mapToValues(Iterable l, Object f) {
    return mapKeyAndFunction(l, f);
  }

  static Map mapToValues(Object f, Iterable l) {
    return mapKeyAndFunction(f, l);
  }

  static <A, B> Map<A, B> mapToValues(Iterable<A> l, IF1<A, B> f) {
    return mapKeyAndFunction(f, l);
  }

  static <A, B> Map<A, B> mapToValues(IF1<A, B> f, Iterable<A> l) {
    return mapKeyAndFunction(f, l);
  }

  static <A, B, C> Map<A, C> mapToValues(Map<A, B> map, IF2<A, B, C> f) {
    return mapKeyAndFunction(map, f);
  }

  static long intPairToLong(IntPair p) {
    return p == null ? 0 : (((long) p.a) << 32) | (((long) p.b) & 0xFFFFFFFF);
  }

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

  static <A> void listPut(List<A> l, int i, A a, A emptyElement) {
    listSet(l, i, a, emptyElement);
  }

  static <A> void listPut(List<A> l, int i, A a) {
    listSet(l, i, a);
  }

  static void assertEqualsIC(String x, String y) {
    assertEqic(x, y);
  }

  static void assertEqualsIC(String msg, String x, String y) {
    assertEqic(msg, x, y);
  }

  static String assertEquals_quote(String x, String y) {
    return assertEquals_quote(null, x, y);
  }

  static String assertEquals_quote(String msg, String x, String y) {
    if (neq(x, y))
      throw fail((msg != null ? msg + ": " : "") + quote(y) + " != " + quote(x));
    return y;
  }

  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 char charFromHex(String s) {
    return (char) hexToInt(s);
  }

  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 IterableIterator<Integer> countIterator(int b) {
    return countIterator(0, b);
  }

  static IterableIterator<Integer> countIterator(int a, int b) {
    return countIterator_exclusive(a, b);
  }

  static <A> IterableIterator<A> countIterator(int b, IF1<Integer, A> f) {
    return countIterator(0, b, f);
  }

  static <A> IterableIterator<A> countIterator(int a, int b, IF1<Integer, A> f) {
    return countIterator_exclusive(a, b, f);
  }

  static IterableIterator<Integer> countIterator(int a, int b, int step) {
    return countIterator_exclusive_step(a, b, step);
  }

  static <A> IterableIterator<A> countIterator(double a, double b, double step, IF1<Double, A> f) {
    return countIterator_exclusive_step(a, b, step, f);
  }

  static <A> IterableIterator<Double> countIterator(double a, double b, double step) {
    return countIterator_exclusive_step(a, b, step);
  }

  static <A> IterableIterator<A> countIterator(IF1<Double, A> f, double a, double b, double step) {
    return countIterator(a, b, step, f);
  }

  static <A> IterableIterator<A> countIterator(IF1<Integer, A> f, int b) {
    return countIterator(f, 0, b);
  }

  static <A> IterableIterator<A> countIterator(IF1<Integer, A> f, int a, int b) {
    return countIterator_exclusive(a, b, f);
  }

  static String joinNemptiesWithColon(String... strings) {
    return joinNempties(": ", strings);
  }

  static String joinNemptiesWithColon(Collection<String> strings) {
    return joinNempties(": ", strings);
  }

  static String commaCombine(Object... l) {
    return joinNemptiesWithComma(flattenCollectionsAndArrays(ll(l)));
  }

  static int hashCodeFor(Object a) {
    return a == null ? 0 : a.hashCode();
  }

  static TreeMap revTreeMap() {
    return new TreeMap(reverseComparator());
  }

  static IntPair longToIntPair(long l) {
    return new IntPair(firstIntFromLong(l), secondIntFromLong(l));
  }

  static <A, B> MultiSetMap<A, B> multiSetMap_innerCompactHashSet_outerRevTreeMap() {
    return new MultiSetMap<A, B>(descTreeMap()) {

      Set<B> _makeEmptySet() {
        return new CompactHashSet();
      }
    };
  }

  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 int oneMillion() {
    return 1000000;
  }

  static <A> List<A> reverseInPlace(List<A> l) {
    return reverseList(l);
  }

  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 String b(Object contents, Object... params) {
    return tag("b", contents, params);
  }

  static String stringIf(boolean b, String s) {
    return stringIfTrue(b, s);
  }

  static String stringIf(String s, boolean b) {
    return stringIf(b, s);
  }

  static List callFAll(Collection l, Object... args) {
    return callF_all(l, args);
  }

  static <A, B> A firstKey(Map<A, B> map) {
    return first(keys(map));
  }

  static <A, B> A firstKey(MultiSetMap<A, B> map) {
    return map == null ? null : firstKey(map.data);
  }

  static <A, B> A firstKey(MultiMap<A, B> map) {
    return map == null ? null : firstKey(map.data);
  }

  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 <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 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 <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 int hashSetCapacity(HashSet set) {
    return (int) call(get(set, "map"), "capacity");
  }

  static long toMS(double seconds) {
    return (long) (seconds * 1000);
  }

  static long now_virtualTime;

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

  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 BufferedReader rawByteReader(InputStream in) {
    return rawByteReader(in, 8192);
  }

  static BufferedReader rawByteReader(InputStream in, int bufSize) {
    try {
      return bufferedReader(_registerIOWrap(new InputStreamReader(in, "ISO-8859-1"), in), bufSize);
    } catch (Exception __e) {
      throw rethrow(__e);
    }
  }

  static BufferedReader rawByteReader(File f) {
    try {
      return rawByteReader(newFileInputStream(f));
    } catch (Exception __e) {
      throw rethrow(__e);
    }
  }

  static BufferedReader rawByteReader(File f, int bufSize) {
    try {
      return rawByteReader(newFileInputStream(f), bufSize);
    } catch (Exception __e) {
      throw rethrow(__e);
    }
  }

  static long fileSize(String path) {
    return getFileSize(path);
  }

  static long fileSize(File f) {
    return getFileSize(f);
  }

  static BufferedInputStream bufferedFileInputStream(File f) {
    return bufferedInputStream(f);
  }

  static BufferedInputStream bufferedFileInputStream(File f, int bufSize) {
    try {
      return new BufferedInputStream(new FileInputStream(f), bufSize);
    } catch (Exception __e) {
      throw rethrow(__e);
    }
  }

  static byte[] isGZipFile_magic = bytesFromHex("1f8b08");

  static boolean isGZipFile(File f) {
    return byteArraysEqual(isGZipFile_magic, loadBeginningOfBinaryFile(f, l(isGZipFile_magic)));
  }

  static GZIPInputStream gzipInputStream(File f) {
    return newGZIPInputStream(f);
  }

  static GZIPInputStream gzipInputStream(InputStream in) {
    return newGZIPInputStream(in);
  }

  static String readLineIgnoreCR(Reader reader) {
    return readLineIgnoreCR(reader, null);
  }

  static String readLineIgnoreCR(Reader reader, StringBuilder buf) {
    try {
      int ch;
      if (buf == null)
        buf = new StringBuilder();
      else
        buf.setLength(0);
      while ((ch = reader.read()) >= 0) {
        if (ch == '\n')
          break;
        buf.append((char) ch);
      }
      return str(buf);
    } catch (Exception __e) {
      throw rethrow(__e);
    }
  }

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

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

  static long twoIntsToLong(int a, int b) {
    return (((long) a) << 32) | (((long) b) & 0xFFFFFFFF);
  }

  static int intPercentRatio(double x, double y) {
    return ratioToIntPercent(x, y);
  }

  static String nPairs(long n) {
    return n2(n, "pair");
  }

  static String nPairs(Collection l) {
    return nPairs(l(l));
  }

  static String nPairs(Map map) {
    return nPairs(l(map));
  }

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

  static List<Integer> compactIntList(List<Integer> l) {
    return l == null ? null : new IntBuffer(l).asVirtualList();
  }

  static List<Integer> parseInts(Iterable<String> l) {
    return lambdaMap(__42 -> parseInt(__42), l);
  }

  static List<String> splitAtSpace(String s) {
    return empty(s) ? emptyList() : asList(s.split("\\s+"));
  }

  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 "ret 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 "ret 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 "ret 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 str(cb.getSelectedItem());
  }

  static int firstIntFromLong(long l) {
    return (int) (l >> 32);
  }

  static int secondIntFromLong(long l) {
    return (int) l;
  }

  static long longSum(Iterable<Long> l) {
    long sum = 0;
    for (Long i : unnull(l)) if (i != null)
      sum += i;
    return sum;
  }

  static <A> long longSum(IF1<A, Long> f, Iterable<A> l) {
    return longSum(mapI(f, l));
  }

  static <A> List<A> syncAddOrCreate(List<A> l, A a) {
    if (l == null)
      l = syncList();
    l.add(a);
    return l;
  }

  static int lLongArray(long[] a) {
    return a == null ? 0 : a.length;
  }

  static long[] resizeLongArray(long[] a, int n) {
    if (n == lLongArray(a))
      return a;
    long[] b = new long[n];
    arraycopy(a, 0, b, 0, Math.min(lLongArray(a), n));
    return b;
  }

  static int maximumSafeArraySize() {
    return Integer.MAX_VALUE - 8;
  }

  static <A> ArrayList<Long> longArrayToList(long[] a) {
    if (a == null)
      return null;
    return longArrayToList(a, 0, a.length);
  }

  // no range checking on from/to in the interest of S P E E E E E EEED
  static <A> ArrayList<Long> longArrayToList(long[] a, int from, int to) {
    if (a == null)
      return null;
    ArrayList<Long> l = new ArrayList<>(to - from);
    for (int i = from; i < to; i++) l.add(a[i]);
    return l;
  }

  static <A> List<A> asVirtualList(A[] a) {
    return wrapArrayAsList(a);
  }

  static <A> List<A> listFromFunction(int n, IF1<Integer, A> f) {
    return new RandomAccessAbstractList<A>() {

      public int size() {
        return n;
      }

      public A get(int i) {
        return f.get(i);
      }
    };
  }

  static <A> List<A> listFromFunction(IF1<Integer, A> f, int n) {
    return listFromFunction(n, f);
  }

  static String squareBracket(String s) {
    return "[" + s + "]";
  }

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

  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 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 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 <A> A println(A a) {
    return print(a);
  }

  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 double floor(double d) {
    return Math.floor(d);
  }

  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 int lIntArray(int[] a) {
    return a == null ? 0 : a.length;
  }

  static int[] resizeIntArray(int[] a, int n) {
    if (n == lIntArray(a))
      return a;
    int[] b = new int[n];
    arraycopy(a, 0, b, 0, Math.min(lIntArray(a), n));
    return b;
  }

  static <A> ArrayList<Integer> intArrayToList(int[] a) {
    if (a == null)
      return null;
    return intArrayToList(a, 0, a.length);
  }

  // no range checking on from/to in the interest of S P E E E E E EEED
  static <A> ArrayList<Integer> intArrayToList(int[] a, int from, int to) {
    if (a == null)
      return null;
    ArrayList<Integer> l = new ArrayList<>(to - from);
    for (int i = from; i < to; i++) l.add(a[i]);
    return l;
  }

  static IntegerIterator integerIterator(int[] l) {
    return l == null ? null : new IntegerIterator() {

      int i = 0;

      public boolean hasNext() {
        return i < l.length;
      }

      public int next() {
        return l[i++];
      }
    };
  }

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

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

  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 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 String dropNumberPrefix(String s) {
    return dropFirst(s, indexOfNonDigit(s));
  }

  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 Map synchroLinkedHashMap() {
    return synchronizedMap(new LinkedHashMap());
  }

  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 Iterator emptyIterator() {
    return Collections.emptyIterator();
  }

  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 <A, B> int lKeys(MultiMap<A, B> mm) {
    return mm == null ? 0 : mm.keysSize();
  }

  // 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 int hashMap_internalHash(Object key) {
    int h;
    return (key == null) ? 0 : (h = key.hashCode()) ^ (h >>> 16);
  }

  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 byte[] charToBytes(char c) {
    return new byte[] { (byte) (c >>> 8), (byte) c };
  }

  static List<Character> stringAsCharacterList(final String s) {
    if (s == null)
      return null;
    return new RandomAccessAbstractList<Character>() {

      final int l = l(s);

      public int size() {
        return l;
      }

      public Character get(int i) {
        return s.charAt(i);
      }
    };
  }

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

  // 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 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 int countLines(String s) {
    // yeah could be optimized :-)
    return l(toLines(s));
  }

  static <A> List<A> uniquifyList(Collection<A> l) {
    if (l == null)
      return null;
    if (l(l) < 2)
      return asList(l);
    HashSet<A> set = new HashSet();
    List<A> out = new ArrayList();
    for (A a : l) if (set.add(a))
      out.add(a);
    return out;
  }

  static String formatWithThousands(long l) {
    return formatWithThousandsSeparator(l);
  }

  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 <A> List<A> sortedInPlace(List<A> l, final Object comparator) {
    sort(l, makeComparator(comparator));
    return l;
  }

  static <A> List<A> sortedInPlace(List<A> l) {
    sort(l);
    return l;
  }

  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 Map<String, Integer> listIndexCI(List<String> l) {
    Map<String, Integer> map = ciMap();
    for (int i = 0; i < l(l); i++) map.put(l.get(i), i);
    return map;
  }

  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 List<CriticalAction> beginCriticalAction_inFlight = synchroList();

  static class CriticalAction {

    String description;

    CriticalAction() {
    }

    CriticalAction(String description) {
      this.description = description;
    }

    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) {
          printStackTrace(__e);
        }
      }
      sleepInCleanUp(10);
    }
  }

  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 BufferedReader utf8BufferedReader(InputStream in) {
    return utf8bufferedReader(in);
  }

  static BufferedReader utf8BufferedReader(File f) {
    return utf8bufferedReader(f);
  }

  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 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 Map mapKeyAndFunction(Iterable l, Object f) {
    return mapKeyAndFunction(f, l);
  }

  static Map mapKeyAndFunction(Object f, Iterable l) {
    HashMap map = new HashMap();
    if (l != null)
      for (Object o : l) map.put(o, callF(f, o));
    return map;
  }

  static <A, B, C> Map<A, C> mapKeyAndFunction(Map<A, B> map, IF2<A, B, C> f) {
    HashMap map2 = new HashMap();
    if (map != null)
      for (Map.Entry<? extends A, ? extends B> __0 : _entrySet(map)) {
        A key = __0.getKey();
        B value = __0.getValue();
        map2.put(key, callF(f, key, value));
      }
    return map2;
  }

  static <A, B> Map<A, B> mapKeyAndFunction(Iterable<A> l, IF1<A, B> f) {
    return mapKeyAndFunction(f, l);
  }

  static <A> void listSet(List<A> l, int i, A a, A emptyElement) {
    if (i < 0)
      return;
    while (i >= l(l)) l.add(emptyElement);
    l.set(i, a);
  }

  static <A> void listSet(List<A> l, int i, A a) {
    listSet(l, i, a, null);
  }

  static void assertEqic(String x, String y) {
    assertEqic(null, x, y);
  }

  static void assertEqic(String msg, String x, String y) {
    if (!eqic(x, y))
      throw fail((msg != null ? msg + ": " : "") + quote(x) + " != " + quote(y) + " [ic]");
  }

  // 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 int hexToInt(String s) {
    return Integer.parseInt(s, 16);
  }

  static IterableIterator<Integer> countIterator_exclusive(int b) {
    return countIterator_exclusive(0, b);
  }

  static IterableIterator<Integer> countIterator_exclusive(int a, int b) {
    return new IterableIterator<Integer>() {

      int i = a;

      public boolean hasNext() {
        return i < b;
      }

      public Integer next() {
        return i++;
      }
    };
  }

  static <A> IterableIterator<A> countIterator_exclusive(int b, IF1<Integer, A> f) {
    return countIterator_exclusive(0, b, f);
  }

  static <A> IterableIterator<A> countIterator_exclusive(int a, int b, IF1<Integer, A> f) {
    return mapI_if1(f, countIterator_exclusive(a, b));
  }

  static IterableIterator<Integer> countIterator_exclusive_step(final int a, final int b, final int step) {
    assertTrue("step > 0", step > 0);
    return new IterableIterator<Integer>() {

      int i = a;

      public boolean hasNext() {
        return i < b;
      }

      public Integer next() {
        var j = i;
        i += step;
        return j;
      }
    };
  }

  static IterableIterator<Double> countIterator_exclusive_step(double a, double b, double step) {
    assertTrue("step > 0", step > 0);
    return new IterableIterator<Double>() {

      double i = a;

      public boolean hasNext() {
        return i < b;
      }

      public Double next() {
        var j = i;
        i += step;
        return j;
      }
    };
  }

  static <A> IterableIterator<A> countIterator_exclusive_step(double a, double b, double step, IF1<Double, A> f) {
    return mapI_if1(f, countIterator_exclusive_step(a, b, step));
  }

  static String joinNempties(String sep, Object... strings) {
    return joinStrings(sep, strings);
  }

  static String joinNempties(String sep, Iterable strings) {
    return joinStrings(sep, strings);
  }

  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 <A> Comparator<A> reverseComparator(Comparator<A> c) {
    return (a, b) -> c.compare(b, a);
  }

  static <A> Comparator<A> reverseComparator() {
    return (a, b) -> cmp(b, a);
  }

  static TreeMap descTreeMap() {
    return revTreeMap();
  }

  static void addToContainer(Container a, Component... b) {
    if (a == null)
      return;
    {
      swing(new Runnable() {

        public void run() {
          try {
            for (Component c : unnullForIteration(b)) if (c != null)
              a.add(c);
          } catch (Exception __e) {
            throw rethrow(__e);
          }
        }

        public String toString() {
          return "for (Component c : unnullForIteration(b))\r\n      if (c != null) \r\n        a.a...";
        }
      });
    }
  }

  static <A> List<A> reverseList(List<A> l) {
    Collections.reverse(l);
    return l;
  }

  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 String tag(String tag) {
    return htag(tag);
  }

  static String tag(String tag, Object contents, Object... params) {
    return htag(tag, str(contents), params);
  }

  static String tag(String tag, StringBuilder contents, Object... params) {
    return htag(tag, contents, params);
  }

  static String tag(String tag, StringBuffer contents, Object... params) {
    return htag(tag, contents, params);
  }

  static String stringIfTrue(boolean b, String s) {
    return b ? s : "";
  }

  static List callF_all(Collection l, Object... args) {
    return map(l, f -> callF(f, args));
  }

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

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

  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 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 <A> A _registerIOWrap(A wrapper, Object wrapped) {
    return wrapper;
  }

  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 int bufferedInputStream_bufferSize = 65536;

  static BufferedInputStream bufferedInputStream(int bufSize, File f) {
    try {
      return bufferedInputStream(bufSize, newFileInputStream(f));
    } catch (Exception __e) {
      throw rethrow(__e);
    }
  }

  static BufferedInputStream bufferedInputStream(File f) {
    try {
      return bufferedInputStream(newFileInputStream(f));
    } catch (Exception __e) {
      throw rethrow(__e);
    }
  }

  static BufferedInputStream bufferedInputStream(InputStream in) {
    return new BufferedInputStream(in, bufferedInputStream_bufferSize);
  }

  static BufferedInputStream bufferedInputStream(int bufSize, InputStream in) {
    return new BufferedInputStream(in, bufSize);
  }

  static byte[] bytesFromHex(String s) {
    return hexToBytes(s);
  }

  static boolean byteArraysEqual(byte[] a, byte[] b) {
    return Arrays.equals(a, b);
  }

  static byte[] loadBeginningOfBinaryFile(File file, int maxBytes) {
    return loadBinaryFilePart(file, 0, maxBytes);
  }

  static GZIPInputStream newGZIPInputStream(File f) {
    return gzInputStream(f);
  }

  static GZIPInputStream newGZIPInputStream(InputStream in) {
    return gzInputStream(in);
  }

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

  static int ratioToIntPercent(double x, double y) {
    return roundToInt(x * 100 / y);
  }

  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 void swingAndWait(Runnable r) {
    try {
      if (isAWTThread())
        r.run();
      else
        EventQueue.invokeAndWait(addThreadInfoToRunnable(r));
    } catch (Exception __e) {
      throw rethrow(__e);
    }
  }

  static Object swingAndWait(final Object f) {
    if (isAWTThread())
      return callF(f);
    else {
      final Var result = new Var();
      swingAndWait(new Runnable() {

        public void run() {
          try {
            result.set(callF(f));
          } catch (Exception __e) {
            throw rethrow(__e);
          }
        }

        public String toString() {
          return "result.set(callF(f));";
        }
      });
      return result.get();
    }
  }

  static 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 "ret cb.isEditable();";
      }
    });
  }

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

  static <A> List<A> syncList(List<A> l) {
    return synchroList(l);
  }

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

  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 <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 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 char lastChar(String s) {
    return empty(s) ? '\0' : s.charAt(l(s) - 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 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 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 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 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;
  }

  // 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 String formatWithThousandsSeparator(long l) {
    return NumberFormat.getInstance(new Locale("en_US")).format(l);
  }

  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 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 <A> TreeMap<String, A> ciMap() {
    return caseInsensitiveMap();
  }

  static void sleepInCleanUp(long ms) {
    try {
      if (ms < 0)
        return;
      Thread.sleep(ms);
    } catch (Exception __e) {
      throw rethrow(__e);
    }
  }

  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 void _registerIO(Object object, String path, boolean opened) {
  }

  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 String appendColonIfNempty(String s) {
    return empty(s) ? "" : s + ": ";
  }

  static CloseableIterableIterator<String> linesFromFile(File f) {
    return linesFromFile(f, null);
  }

  static CloseableIterableIterator<String> linesFromFile(File f, IResourceHolder resourceHolder) {
    try {
      if (!f.exists())
        return emptyCloseableIterableIterator();
      if (ewic(f.getName(), ".gz"))
        return linesFromReader(utf8bufferedReader(newGZIPInputStream(f)), resourceHolder);
      return linesFromReader(utf8bufferedReader(f), resourceHolder);
    } catch (Exception __e) {
      throw rethrow(__e);
    }
  }

  static CloseableIterableIterator<String> linesFromFile(String path) {
    return linesFromFile(path, null);
  }

  static CloseableIterableIterator<String> linesFromFile(String path, IResourceHolder resourceHolder) {
    return linesFromFile(newFile(path), resourceHolder);
  }

  static class mapI_if1_It<A, B> extends IterableIterator<B> {

    IF1<A, B> f;

    Iterator<A> i;

    mapI_if1_It() {
    }

    mapI_if1_It(IF1<A, B> f, Iterator<A> i) {
      this.i = i;
      this.f = f;
    }

    public boolean hasNext() {
      return i.hasNext();
    }

    public B next() {
      return f.get(i.next());
    }

    public String toString() {
      return formatFunctionCall("mapI_if1", f, i);
    }
  }

  static <A, B> IterableIterator<B> mapI_if1(IF1<A, B> f, Iterable<A> i) {
    return new mapI_if1_It(f, i.iterator());
  }

  static <A, B> IterableIterator<B> mapI_if1(Iterable<A> i, IF1<A, B> f) {
    return mapI_if1(f, i);
  }

  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 Object swing(Object f) {
    return 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 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 String htag(String tag) {
    return htag(tag, "");
  }

  static String htag(String tag, Object contents, Object... params) {
    String openingTag = hopeningTag(tag, params);
    String s = str(contents);
    if (empty(s) && neqic(tag, "script"))
      return dropLast(openingTag) + "/>";
    return openingTag + s + "</" + tag + ">";
  }

  static <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 <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 programID() {
    return getProgramID();
  }

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

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

  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))
        // for stuff like "don't"
        do ++j; while (j < l && (Character.isJavaIdentifierPart(s.charAt(j)) || "'".indexOf(s.charAt(j)) >= 0));
      else if (Character.isDigit(c)) {
        do ++j; while (j < l && Character.isDigit(s.charAt(j)));
        // Long constants like 1L
        if (j < l && s.charAt(j) == 'L')
          ++j;
      } else if (c == '[' && d == '[') {
        do ++j; while (j + 1 < l && !s.substring(j, j + 2).equals("]]"));
        j = Math.min(j + 2, l);
      } else if (c == '[' && d == '=' && i + 2 < l && s.charAt(i + 2) == '[') {
        do ++j; while (j + 2 < l && !s.substring(j, j + 3).equals("]=]"));
        j = Math.min(j + 3, l);
      } else
        ++j;
      tok.add(javaTok_substringC(s, i, j));
      i = j;
    }
    return tok;
  }

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

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

  // 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;

  // stats
  static int unstructure_tokrefs;

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

  static Object unstructure_tok(final Producer<String> tok, final boolean allDynamic, final Object _classFinder) {
    final boolean debug = unstructure_debug;
    final class X {

      int i = -1;

      final Object classFinder = _classFinder != null ? _classFinder : _defaultClassFinder();

      String mcDollar = actualMCDollar();

      // 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();

      HashMap<String, Class> classesMap = new HashMap();

      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];

      X() {
        try {
          Class mc = (Class) (callF(_classFinder, "<main>"));
          if (mc != null)
            mcDollar = mc.getName() + "$";
        } catch (Throwable __e) {
          printStackTrace(__e);
        }
      }

      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));
        String cname = t;
        Class c = classesMap.get(cname);
        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("bigint")) {
            out.set(parseBigInt());
            return;
          }
          if (t.equals("d")) {
            out.set(parseDouble());
            return;
          }
          if (t.equals("fl")) {
            out.set(parseFloat());
            return;
          }
          if (t.equals("sh")) {
            consume();
            t = tpp();
            if (t.equals("-")) {
              t = tpp();
              out.set((short) (-parseInt(t)));
              return;
            }
            out.set((short) parseInt(t));
            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("false") || t.equals("f")) {
            consume();
            out.set(false);
            return;
          }
          if (t.equals("true") || t.equals("t")) {
            consume();
            out.set(true);
            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("{")) {
            parseMap(out);
            return;
          }
          if (t.equals("[")) {
            ArrayList l = new ArrayList();
            if (refID >= 0)
              refs.put(refID, l);
            this.parseList(l, out);
            return;
          }
          if (t.equals("bitset")) {
            parseBitSet(out);
            return;
          }
          if (t.equals("array") || t.equals("intarray") || t.equals("dblarray")) {
            parseArray(out);
            return;
          }
          if (t.equals("ba")) {
            consume();
            String hex = unquote(tpp());
            out.set(hexToBytes(hex));
            return;
          }
          if (t.equals("boolarray")) {
            consume();
            int n = parseInt(tpp());
            String hex = unquote(tpp());
            out.set(boolArrayFromBytes(hexToBytes(hex), n));
            return;
          }
          if (t.equals("class")) {
            out.set(parseClass());
            return;
          }
          if (t.equals("l")) {
            parseLisp(out);
            return;
          }
          if (t.equals("null")) {
            consume();
            out.set(null);
            return;
          }
          if (eq(t, "c")) {
            consume();
            t = t();
            assertTrue(isJavaIdentifier(t));
            concepts.add(t);
          }
          // 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 = classesMap.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(), ".")) {
          consume();
          className = fullClassName = t + "." + assertIdentifier(tpp());
        } else {
          className = t;
          fullClassName = mcDollar + t;
        }
        if (c == null && !allDynamic) {
          // First, find class
          c = findAClass(fullClassName);
          classesMap.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);
              classesMap.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;
        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;
        }
        // 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!
        // no longer preserving order (why did we do this?)
        HashMap<String, Object> fields = new HashMap();
        Object _o = o;
        DynamicObject _dO = dO;
        if (hasBracket) {
          stack.add(new Runnable() {

            public void run() {
              try {
                if (eq(t(), ","))
                  consume();
                if (eq(t(), ")")) {
                  consume(")");
                  objRead(_o, _dO, fields, hasOuter);
                  out.set(_o != null ? _o : _dO);
                } else {
                  final String key = unquote(tpp());
                  String t = tpp();
                  if (!eq(t, "="))
                    throw fail("= expected, got " + t + " after " + quote(key) + " in object " + thingName);
                  stack.add(this);
                  parse(new unstructure_Receiver() {

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

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

      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("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);
        dO.fieldValues.put("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
          }
        });
      }

      /*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) {
        // get first token
        consume();
        parse(out);
        while (nempty(stack)) popLast(stack).run();
      }
    }
    ThreadLocal<Boolean> tlLoading = dynamicObjectIsLoading_threadLocal();
    Boolean b = tlLoading.get();
    tlLoading.set(true);
    try {
      final Var v = new Var();
      X x = new X();
      x.parse_initial(new unstructure_Receiver() {

        void set(Object o) {
          v.set(o);
        }
      });
      unstructure_tokrefs = x.tokrefs.size();
      return v.get();
    } finally {
      tlLoading.set(b);
    }
  }

  static boolean unstructure_debug = false;

  static Producer<String> javaTokC_noMLS_onReader(final BufferedReader r) {
    final class X implements Producer<String> {

      // stores from "i"
      StringBuilder buf = new StringBuilder();

      // just not '\0'
      char c, d, e = 'x';

      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' : // shouldn't happen anymore
          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))
          // for stuff like "don't"
          do ncSave(); while (Character.isJavaIdentifierPart(c) || c == '\'');
        else if (Character.isDigit(c)) {
          do ncSave(); while (Character.isDigit(c));
          // Long constants like 1L
          if (c == 'L')
            ncSave();
        } else
          ncSave();
        String t = buf.toString();
        buf.setLength(0);
        return t;
      }
    }
    return new X();
  }

  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 byte[] loadBinaryFilePart(File file, long start, long end) {
    try {
      RandomAccessFile raf = new RandomAccessFile(file, "r");
      int n = toInt(min(raf.length(), end - start));
      byte[] buffer = new byte[n];
      try {
        raf.seek(start);
        raf.readFully(buffer, 0, n);
        return buffer;
      } finally {
        raf.close();
      }
    } catch (Exception __e) {
      throw rethrow(__e);
    }
  }

  static 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 int roundToInt(double d) {
    return (int) Math.round(d);
  }

  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 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 double parseDouble(String s) {
    return empty(s) ? 0.0 : Double.parseDouble(s);
  }

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

  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 boolean isDigit(char c) {
    return Character.isDigit(c);
  }

  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 <A> TreeMap<String, A> caseInsensitiveMap() {
    return new TreeMap(caseInsensitiveComparator());
  }

  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 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 "ret readLineFromReaderWithClose(br);";
      }
    }, _wrapIOCloseable(r)));
  }

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

  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 boolean neqic(String a, String b) {
    return !eqic(a, b);
  }

  static boolean neqic(char a, char b) {
    return !eqic(a, b);
  }

  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 String javaTok_substringC(String s, int i, int j) {
    return s.substring(i, j);
  }

  static boolean sameSnippetID(String a, String b) {
    if (!isSnippetID(a) || !isSnippetID(b))
      return false;
    return parseSnippetID(a) == parseSnippetID(b);
  }

  // can be set to work on different base dir
  static File javaxDataDir_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 volatile String caseID_caseID;

  static String caseID() {
    return caseID_caseID;
  }

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

  static ThreadLocal<VF1<File>> checkFileNotTooBigToRead_tl = new ThreadLocal();

  static void checkFileNotTooBigToRead(File f) {
    callF(checkFileNotTooBigToRead_tl.get(), f);
  }

  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)));
          // Long constants like 1L
          if (j < l && s.charAt(j) == 'L')
            ++j;
        } else
          ++j;
        String t = quickSubstring(s, i, j);
        i = j;
        return t;
      }
    };
  }

  static Object _defaultClassFinder_value = defaultDefaultClassFinder();

  static Object _defaultClassFinder() {
    return _defaultClassFinder_value;
  }

  static String actualMCDollar() {
    return actualMC().getName() + "$";
  }

  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 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();
        // fallback
        if (l > buf.length)
          return unquote(s);
        int n = 0;
        for (int i = 1; i < l; i++) {
          char ch = s.charAt(i);
          if (ch == '\\') {
            char nextChar = (i == l - 1) ? '\\' : s.charAt(i + 1);
            // 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:
                // added by Stefan
                ch = nextChar;
            }
            i++;
          }
          buf[n++] = ch;
        }
        return new String(buf, 0, n);
      }
    }
    // not quoted - return original
    return s;
  }

  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 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 BigInteger parseBigInt(String s) {
    return new BigInteger(s);
  }

  static float parseFloat(String s) {
    return Float.parseFloat(s);
  }

  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 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 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 List parseList(String s) {
    return (List) safeUnstructure(s);
  }

  static <A> List<A> synchroLinkedList() {
    return Collections.synchronizedList(new LinkedList<A>());
  }

  static <A, B> NavigableMap<A, B> synchroNavigableMap(NavigableMap<A, B> map) {
    return (NavigableMap) call(Collections.class, "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 isJavaIdentifier(String s) {
    if (empty(s) || !Character.isJavaIdentifierStart(s.charAt(0)))
      return false;
    for (int i = 1; i < s.length(); i++) if (!Character.isJavaIdentifierPart(s.charAt(i)))
      return false;
    return true;
  }

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

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

  // 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 <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 : c.getDeclaredConstructors()) 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) {
        printStackTrace(__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 String intern(String s) {
    return fastIntern(s);
  }

  static void pcallOpt_noArgs(Object o, String method) {
    try {
      callOpt_noArgs(o, method);
    } catch (Throwable __e) {
      printStackTrace(__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 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(IntBuffer b) {
    int n = l(b);
    double[] a = new double[n];
    for (int i = 0; i < n; i++) a[i] = b.get(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 String dropPrefix(String prefix, String s) {
    return s == null ? null : s.startsWith(prefix) ? s.substring(l(prefix)) : s;
  }

  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 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 {
      // cached!
      if (args.length == 0)
        return nuObjectWithoutArguments(c);
      Constructor m = nuObject_findConstructor(c, args);
      makeAccessible(m);
      return (A) m.newInstance(args);
    } catch (Exception __e) {
      throw rethrow(__e);
    }
  }

  static Constructor nuObject_findConstructor(Class c, Object... args) {
    for (Constructor m : c.getDeclaredConstructors()) {
      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 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 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 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 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 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 Runnable asRunnable(Object o) {
    return toRunnable(o);
  }

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

  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 <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 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 String formatSnippetID(String id) {
    return "#" + parseSnippetID(id);
  }

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

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

  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 String _userHome;

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

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

  static String quickSubstring(String s, int i, int j) {
    if (i == j)
      return "";
    return s.substring(i, j);
  }

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

      public Class get(String name) {
        Class c = get2(name);
        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);
            {
              Class c = findClass_fullName(newName);
              if (c != null)
                return c;
            }
          }
        return null;
      }
    };
  }

  static Class actualMC() {
    return or((Class) realMC(), mc());
  }

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

  static <A> boolean addToCollection(Collection<A> c, A a) {
    return c != null && c.add(a);
  }

  static Object safeUnstructure(String s) {
    return unstructure(s, true);
  }

  static Object safeUnstructure(File f) {
    return safeUnstructureGZFile(f);
  }

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

  // Use like this: renderVars(+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 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 String exceptionToStringShort(Throwable e) {
    lastException(e);
    e = getInnerException(e);
    String msg = hideCredentials(unnull(e.getMessage()));
    if (msg.indexOf("Error") < 0 && msg.indexOf("Exception") < 0)
      return baseClassName(e) + prependIfNempty(": ", msg);
    else
      return msg;
  }

  static void warnIfOddCount(Object... list) {
    if (odd(l(list)))
      printStackTrace("Odd list size: " + list);
  }

  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 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 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)
        // not optimized
        return callOpt(o, method);
      Class c = o.getClass();
      HashMap<String, Method> map;
      synchronized (callOpt_noArgs_cache) {
        map = callOpt_noArgs_cache.get(c);
        if (map == null)
          map = callOpt_noArgs_makeCache(c);
      }
      Method m = map.get(method);
      return m != null ? m.invoke(o) : null;
    } catch (Exception __e) {
      throw rethrow(__e);
    }
  }

  // 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))
        // for stuff like "don't"
        do ++j; while (j < l && (Character.isJavaIdentifierPart(s.charAt(j)) || s.charAt(j) == '\''));
      else if (Character.isDigit(c)) {
        do ++j; while (j < l && Character.isDigit(s.charAt(j)));
        // Long constants like 1L
        if (j < l && s.charAt(j) == 'L')
          ++j;
      } else if (c == '[' && d == '[') {
        do ++j; while (j < l && !regionMatches(s, j, "]]"));
        j = Math.min(j + 2, l);
      } else if (c == '[' && d == '=' && i + 2 < l && s.charAt(i + 2) == '[') {
        do ++j; while (j + 2 < l && !regionMatches(s, j, "]=]"));
        j = Math.min(j + 3, l);
      } else
        ++j;
      tok.add(javaTok_substringC(s, i, j));
      i = j;
    }
    if ((tok.size() % 2) == 0)
      tok.add("");
    javaTok_elements += tok.size();
    return tok;
  }

  static List<String> javaTok(List<String> tok) {
    return javaTokWithExisting(join(tok), 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);
    // We're modifying it, so copy first
    pat = new ArrayList<String>(pat);
    pat.set(i, "*");
    while (pat.size() < tok.size()) {
      pat.add(i, "*");
      // doesn't matter
      pat.add(i + 1, "");
    }
    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 (// bold change - match quoted and unquoted now. TODO: should remove
      !equalsIgnoreCase(unquote(p), unquote(t)))
        return null;
    }
    return result.toArray(new String[result.size()]);
  }

  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 : c.getDeclaredConstructors()) if (empty(m.getParameterTypes())) {
      makeAccessible(m);
      return m;
    }
    throw fail("No default constructor found in " + c.getName());
  }

  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 int charDiff(char a, char b) {
    return (int) a - (int) b;
  }

  static int charDiff(String a, char b) {
    return charDiff(stringToChar(a), b);
  }

  static Runnable toRunnable(final Object o) {
    if (o instanceof Runnable)
      return (Runnable) o;
    return new Runnable() {

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

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

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

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

  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 Class loadClassFromClassLoader_orNull(ClassLoader cl, String name) {
    try {
      return cl == null ? null : cl.loadClass(name);
    } catch (ClassNotFoundException e) {
      return null;
    }
  }

  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 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 File userDir() {
    return new File(userHome());
  }

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

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

  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 Object realMC() {
    return getThreadLocal(realMC_tl());
  }

  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 boolean isIdentifier(String s) {
    return isJavaIdentifier(s);
  }

  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 String prependIfNempty(String prefix, String s) {
    return empty(s) ? unnull(s) : prefix + s;
  }

  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(Iterable<A> c, Class<A> type) {
    A[] a = arrayOfType(l(c), type);
    if (a.length == 0)
      return a;
    asList(c).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 void upgradeJavaXAndRestart() {
    run("#1001639");
    restart();
    sleep();
  }

  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))
        // for stuff like "don't"
        do ++j; while (j < l && (Character.isJavaIdentifierPart(s.charAt(j)) || "'".indexOf(s.charAt(j)) >= 0));
      else if (Character.isDigit(c)) {
        do ++j; while (j < l && Character.isDigit(s.charAt(j)));
        // Long constants like 1L
        if (j < l && s.charAt(j) == 'L')
          ++j;
      } else if (c == '[' && d == '[') {
        do ++j; while (j + 1 < l && !s.substring(j, j + 2).equals("]]"));
        j = Math.min(j + 2, l);
      } else if (c == '[' && d == '=' && i + 2 < l && s.charAt(i + 2) == '[') {
        do ++j; while (j + 2 < l && !s.substring(j, j + 3).equals("]=]"));
        j = Math.min(j + 3, l);
      } else
        ++j;
      if (n < nExisting && javaTokWithExisting_isCopyable(existing.get(n), s, i, j))
        tok.add(existing.get(n));
      else
        tok.add(javaTok_substringC(s, i, j));
      ++n;
      i = j;
    }
    if ((tok.size() % 2) == 0)
      tok.add("");
    javaTok_elements += tok.size();
    return tok;
  }

  static boolean javaTokWithExisting_isCopyable(String t, String s, int i, int j) {
    return t.length() == j - i && // << could be left out, but that's brave
    s.regionMatches(i, t, 0, j - i);
  }

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

  static boolean equalsIgnoreCase(char a, char b) {
    return eqic(a, b);
  }

  static char stringToChar(String s) {
    if (l(s) != 1)
      throw fail("bad stringToChar: " + s);
    return firstChar(s);
  }

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

  static ThreadLocal realMC_tl_tl = new ThreadLocal();

  static ThreadLocal realMC_tl() {
    return realMC_tl_tl;
  }

  static boolean fileExists(String path) {
    return path != null && new File(path).exists();
  }

  static boolean fileExists(File f) {
    return f != null && f.exists();
  }

  static Throwable getException(Runnable r) {
    try {
      callF(r);
      return null;
    } catch (Throwable e) {
      return e;
    }
  }

  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 char firstChar(String s) {
    return s.charAt(0);
  }

  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 interface IResourceHolder {

    <A extends AutoCloseable> A add(A a);

    Collection<AutoCloseable> takeAll();
  }

  static abstract class CloseableIterableIterator<A> extends IterableIterator<A> implements AutoCloseable {

    public void close() throws Exception {
    }
  }

  static interface Producer<A> {

    // null when end
    public A next();
  }

  // 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> {

    // pointer to last element in chain (which may be us)
    MinimalChain<A> last;

    // total length of chain
    int size;

    // only used internally
    AppendableChain() {
    }

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

  static class Var<A> implements IVar<A>, ISetter<A> {

    Var() {
    }

    Var(A v) {
      this.v = v;
    }

    // you can access this directly if you use one thread
    A v;

    public synchronized void set(A a) {
      if (v != a) {
        v = a;
        notifyAll();
      }
    }

    public synchronized A get() {
      return v;
    }

    public synchronized boolean has() {
      return v != null;
    }

    public void clear() {
      set(null);
    }

    public String toString() {
      return str(this.get());
    }
  }

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