import java.util.*;
import java.util.zip.*;
import java.util.List;
import java.util.regex.*;
import java.util.concurrent.*;
import java.util.concurrent.atomic.*;
import java.util.concurrent.locks.*;
import java.util.function.*;
import javax.swing.*;
import javax.swing.event.*;
import javax.swing.text.*;
import javax.swing.table.*;
import java.io.*;
import java.net.*;
import java.lang.reflect.*;
import java.lang.ref.*;
import java.lang.management.*;
import java.security.*;
import java.security.spec.*;
import java.awt.*;
import java.awt.event.*;
import java.awt.image.*;
import java.awt.geom.*;
import javax.imageio.*;
import java.math.*;
import net.lingala.zip4j.model.*;
import net.lingala.zip4j.io.outputstream.*;
import net.lingala.zip4j.model.enums.*;
import net.lingala.zip4j.headers.*;
import net.lingala.zip4j.util.*;
import java.util.zip.ZipOutputStream;
import static x30_pkg.x30_util.DynamicObject;
import java.awt.geom.*;
import java.nio.charset.Charset;

class main {

  // zip4j-2.9.1
  static class Zip4j_CopySubSetOfZipFile implements IFieldsToList {

    File zipIn;

    File zipOut;

    IF1<String, Boolean> fileFilter;

    Zip4j_CopySubSetOfZipFile() {
    }

    Zip4j_CopySubSetOfZipFile(File zipIn, File zipOut, IF1<String, Boolean> fileFilter) {
      this.fileFilter = fileFilter;
      this.zipOut = zipOut;
      this.zipIn = zipIn;
    }

    public String toString() {
      return shortClassName_dropNumberPrefix(this) + "(" + zipIn + ", " + zipOut + ", " + fileFilter + ")";
    }

    public Object[] _fieldsToList() {
      return new Object[] { zipIn, zipOut, fileFilter };
    }

    ZipModel zipModel;

    HeaderWriter headerWriter = new HeaderWriter();

    net.lingala.zip4j.progress.ProgressMonitor progressMonitor = new net.lingala.zip4j.progress.ProgressMonitor();

    int bufferSize = InternalZipConstants.BUFF_SIZE;

    Charset charset;

    public void run() {
      try {
        try (var randomAccessFile = new RandomAccessFile(zipIn, RandomAccessFileMode.READ.getValue())) {
          zipModel = new HeaderReader().readAllHeaders(randomAccessFile, buildConfig());
          zipModel.setZipFile(zipIn);
        }
        var outputStream = new SplitOutputStream(zipOut);
        try {
          var inputStream = new RandomAccessFile(zipModel.getZipFile(), RandomAccessFileMode.READ.getValue());
          try {
            long currentFileCopyPointer = 0, runningOffset = 0;
            List<FileHeader> sortedFileHeaders = sortedByComparator(zipModel.getCentralDirectory().getFileHeaders(), (o1, o2) -> {
              if (eq(o1.getFileName(), o2.getFileName()))
                return 0;
              return cmp(o1.getOffsetLocalHeader(), o2.getOffsetLocalHeader());
            });
            int count = 0;
            List<FileHeader> filteredFileHeaders = new ArrayList();
            for (int iFileHeader = 0; iFileHeader < l(sortedFileHeaders); iFileHeader++) {
              var fileHeader = sortedFileHeaders.get(iFileHeader);
              var fileHeaderOffset = fileHeader.getOffsetLocalHeader();
              var nextOffset = getOffsetOfNextEntry(sortedFileHeaders, iFileHeader, zipModel);
              long fp = outputStream.getFilePointer();
              long lengthOfCurrentEntry = nextOffset + runningOffset - fp;
              if (count++ < 10)
                printVars("fileHeaderOffset", fileHeaderOffset, "nextOffset", nextOffset, "runningOffset", runningOffset, "lengthOfCurrentEntry", lengthOfCurrentEntry, "fp", fp);
              if (!fileFilter.get(fileHeader.getFileName())) {
                runningOffset -= lengthOfCurrentEntry;
                currentFileCopyPointer += lengthOfCurrentEntry;
              } else {
                addOffsetToFileHeader(fileHeader, runningOffset);
                filteredFileHeaders.add(fileHeader);
                // copy complete entry without any changes
                currentFileCopyPointer += copyFile(inputStream, outputStream, currentFileCopyPointer, lengthOfCurrentEntry, progressMonitor, buildConfig().getBufferSize());
              }
            }
            var endOfCDR = zipModel.getEndOfCentralDirectoryRecord();
            endOfCDR.setTotalNumberOfEntriesInCentralDirectory(l(filteredFileHeaders));
            endOfCDR.setTotalNumberOfEntriesInCentralDirectoryOnThisDisk(l(filteredFileHeaders));
            if (zipModel.isZip64Format()) {
              zipModel.getZip64EndOfCentralDirectoryRecord().setOffsetStartCentralDirectoryWRTStartDiskNumber(zipModel.getZip64EndOfCentralDirectoryRecord().getOffsetStartCentralDirectoryWRTStartDiskNumber() + runningOffset);
              zipModel.getZip64EndOfCentralDirectoryRecord().setTotalNumberOfEntriesInCentralDirectoryOnThisDisk(l(filteredFileHeaders));
              zipModel.getZip64EndOfCentralDirectoryLocator().setOffsetZip64EndOfCentralDirectoryRecord(zipModel.getZip64EndOfCentralDirectoryLocator().getOffsetZip64EndOfCentralDirectoryRecord() + runningOffset);
            }
            zipModel.getCentralDirectory().setFileHeaders(filteredFileHeaders);
            headerWriter.finalizeZipFile(zipModel, outputStream, buildConfig().getCharset());
          } finally {
            _close(inputStream);
          }
        } finally {
          _close(outputStream);
        }
      } catch (Exception __e) {
        throw rethrow(__e);
      }
    }

    long getOffsetOfNextEntry(List<FileHeader> sortedFileHeaders, int indexOfFileHeader, ZipModel zipModel) throws ZipException {
      if (indexOfFileHeader == sortedFileHeaders.size() - 1)
        return HeaderUtil.getOffsetStartOfCentralDirectory(zipModel);
      else
        return sortedFileHeaders.get(indexOfFileHeader + 1).getOffsetLocalHeader();
    }

    long copyFile(RandomAccessFile randomAccessFile, OutputStream outputStream, long start, long length, net.lingala.zip4j.progress.ProgressMonitor progressMonitor, int bufferSize) throws IOException {
      net.lingala.zip4j.util.FileUtils.copyFile(randomAccessFile, outputStream, start, start + length, progressMonitor, bufferSize);
      return length;
    }

    Zip4jConfig buildConfig() {
      return new Zip4jConfig(charset, bufferSize);
    }

    void addOffsetToFileHeader(FileHeader fileHeader, long offsetToAdd) {
      fileHeader.setOffsetLocalHeader(fileHeader.getOffsetLocalHeader() + offsetToAdd);
      if (zipModel.isZip64Format() && fileHeader.getZip64ExtendedInfo() != null && fileHeader.getZip64ExtendedInfo().getOffsetLocalHeader() != -1)
        fileHeader.getZip64ExtendedInfo().setOffsetLocalHeader(fileHeader.getZip64ExtendedInfo().getOffsetLocalHeader() + offsetToAdd);
    }
  }

  static String shortClassName_dropNumberPrefix(Object o) {
    return dropNumberPrefix(shortClassName(o));
  }

  static <A> List<A> sortedByComparator(Collection<A> l, Comparator<A> c) {
    List<A> l2 = cloneList(l);
    sort(l2, c);
    return l2;
  }

  static <A> List<A> sortedByComparator(Comparator<A> c, Collection<A> l) {
    return sortedByComparator(l, c);
  }

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

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

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

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

  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 <A> ArrayList<A> cloneList(Iterable<A> l) {
    return l instanceof Collection ? cloneList((Collection) l) : asList(l);
  }

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

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

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

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

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

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

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

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

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

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

  // 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 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);
    return f;
  }

  static void copyStream(InputStream in, OutputStream out) {
    try {
      byte[] buf = new byte[65536];
      while (true) {
        int n = in.read(buf);
        if (n <= 0)
          return;
        out.write(buf, 0, n);
      }
    } catch (Exception __e) {
      throw rethrow(__e);
    }
  }

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

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

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

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

  // 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) {
    print_raw(s);
  }

  static void print_raw(String 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() {
  }

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

  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 AutoCloseable tempInterceptPrintIfNotIntercepted(F1<String, Boolean> f) {
    return print_byThread().get() == null ? tempInterceptPrint(f) : null;
  }

  static String[] drop(int n, String[] a) {
    n = Math.min(n, a.length);
    String[] b = new String[a.length - n];
    System.arraycopy(a, n, b, 0, b.length);
    return b;
  }

  static Object[] drop(int n, Object[] a) {
    n = Math.min(n, a.length);
    Object[] b = new Object[a.length - n];
    System.arraycopy(a, n, b, 0, b.length);
    return b;
  }

  static <A> 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 String substring(String s, int x) {
    return substring(s, x, strL(s));
  }

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

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

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

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

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

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

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

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

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

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

  static void ping_okInCleanUp() {
  }

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

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

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

  static String trim(StringBuilder buf) {
    return buf.toString().trim();
  }

  static String trim(StringBuffer buf) {
    return buf.toString().trim();
  }

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

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

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

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

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

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

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

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

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

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

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

  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 RuntimeException asRuntimeException(Throwable t) {
    return t instanceof RuntimeException ? (RuntimeException) t : new RuntimeException(t);
  }

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

  // you can change this function to allow interrupting long calculations from the outside. just throw a RuntimeException.
  static boolean ping() {
    return true;
  }

  static boolean ping_impl(boolean okInCleanUp) {
    return true;
  }

  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 int parseInt(String s) {
    return emptyString(s) ? 0 : Integer.parseInt(s);
  }

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

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

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

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

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

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

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

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

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

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

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

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

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

  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 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 = synchroHashMap();
    return vm_generalMap_map;
  }

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

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

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

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

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

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

  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> void callF(VF1<A> f, A a) {
    if (f != null)
      f.get(a);
  }

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

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

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

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

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

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

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

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

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

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

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

  static boolean call_checkArgs(Method m, Object[] args, boolean debug) {
    Class<?>[] types = m.getParameterTypes();
    if (types.length != l(args)) {
      if (debug)
        print("Bad parameter length: " + args.length + " vs " + types.length);
      return false;
    }
    for (int i = 0; i < types.length; i++) {
      Object arg = args[i];
      if (!(arg == null ? !types[i].isPrimitive() : isInstanceX(types[i], arg))) {
        if (debug)
          print("Bad parameter " + i + ": " + arg + " vs " + types[i]);
        return false;
      }
    }
    return true;
  }

  static Field makeAccessible(Field f) {
    try {
      f.setAccessible(true);
    } catch (Throwable e) {
    // Note: The error reporting only works with Java VM option --illegal-access=deny
    }
    return f;
  }

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

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

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

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

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

  static List<Pair> _registerDangerousWeakMap_preList;

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

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

  static void _onLoad_registerDangerousWeakMap() {
  }

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

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

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

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

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

  static boolean 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 List<String> getClassNames(Collection l) {
    List<String> out = new ArrayList();
    if (l != null)
      for (Object o : l) out.add(o == null ? null : getClassName(o));
    return out;
  }

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

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

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

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

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

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

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

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

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

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

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

  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> implements IMultiMap<A, B> {

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

    int fullSize;

    MultiMap() {
    }

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

    // returns actual mutable live list
    // creates the list if not there
    List<B> getActual(A key) {
      synchronized (data) {
        List<B> list = data.get(key);
        if (list == null)
          data.put(key, list = _makeEmptyList());
        return list;
      }
    }

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

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

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

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

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

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

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

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

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

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

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

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

    void putAll(Map<A, B> map) {
      synchronized (data) {
        if (map != null)
          for (Map.Entry<A, B> e : map.entrySet()) put(e.getKey(), e.getValue());
      }
    }

    final public int keyCount() {
      return keysSize();
    }

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

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

    public int size() {
      synchronized (data) {
        return fullSize;
      }
    }

    // expensive operation
    List<A> reverseGet(B b) {
      synchronized (data) {
        List<A> l = new ArrayList();
        for (A key : data.keySet()) if (data.get(key).contains(b))
          l.add(key);
        return l;
      }
    }

    Map<A, List<B>> asMap() {
      synchronized (data) {
        return cloneMap(data);
      }
    }

    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 Hasher<A> {

    int hashCode(A a);

    boolean equals(A a, A b);
  }

  static interface IFieldsToList {

    Object[] _fieldsToList();
  }

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

    RuntimeException asRuntimeException() {
      return new Fail(this);
    }
  }

  static interface IVF1<A> {

    void get(A a);
  }

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

  interface IMultiMap<A, B> {

    public Set<A> keySet();

    public Collection<B> get(A a);

    public int size();

    public int keyCount();
  }

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

  // 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 List<String> quoteAll(String[] l) {
    return quoteAll(asList(l));
  }

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

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

  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 <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, 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 boolean nempty(Collection c) {
    return !empty(c);
  }

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

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

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

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

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

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

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

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

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

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

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

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

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

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

  static Field getOpt_findStaticField(Class<?> c, String field) {
    Class _c = c;
    do {
      for (Field f : _c.getDeclaredFields()) if (f.getName().equals(field) && (f.getModifiers() & java.lang.reflect.Modifier.STATIC) != 0)
        return f;
      _c = _c.getSuperclass();
    } while (_c != null);
    return null;
  }

  static <A> A getAndClear(IVar<A> v) {
    A a = v.get();
    v.set(null);
    return a;
  }

  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(IMultiMap<A, B> mm) {
    return mm.keySet();
  }

  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 <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 <A, B, C extends Collection<B>> List<B> allValues(Map<A, C> map) {
    List<B> out = new ArrayList();
    for (var l : values(map)) addAll(out, l);
    return out;
  }

  static <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 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 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 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 Field getOpt_findField(Class<?> c, String field) {
    Class _c = c;
    do {
      for (Field f : _c.getDeclaredFields()) if (f.getName().equals(field))
        return f;
      _c = _c.getSuperclass();
    } while (_c != null);
    return null;
  }

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

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

  static <A, B extends A> void addAll(Collection<A> c, Iterable<B> b) {
    if (c != null && b != null)
      for (A a : b) c.add(a);
  }

  static <A, B extends A> boolean addAll(Collection<A> c, Collection<B> b) {
    return c != null && b != null && c.addAll(b);
  }

  static <A, B extends A> boolean addAll(Collection<A> c, B... b) {
    return c != null && b != null && c.addAll(Arrays.asList(b));
  }

  static <A, B> Map<A, B> addAll(Map<A, B> a, Map<? extends A, ? extends B> b) {
    if (a != null && b != null)
      a.putAll(b);
    return a;
  }

  static <A extends Container> A addAll(A c, Collection<? extends Component> components) {
    return addComponents(c, components);
  }

  static <A extends Container> A addAll(A c, Component... components) {
    return addComponents(c, components);
  }

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

  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 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 void clear(Collection c) {
    if (c != null)
      c.clear();
  }

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

  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 <A extends Container> A addComponents(A c, Collection<? extends Component> components) {
    if (nempty(components)) {
      swing(() -> {
        for (Component comp : components) c.add(comp);
        revalidate(c);
      });
    }
    return c;
  }

  static <A extends Container> A addComponents(A c, Component... components) {
    return addComponents(c, asList(components));
  }

  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 <A> A[] arrayOfSameType(A[] a, int n) {
    return newObjectArrayOfSameType(a, n);
  }

  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 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 Object swing(Object f) {
    return swingAndWait(f);
  }

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

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

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

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

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

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

  static <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> HashSet<A> lithashset(A... items) {
    HashSet<A> set = new HashSet();
    for (A a : items) set.add(a);
    return set;
  }

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

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

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

  static Boolean isHeadless_cache;

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

  static 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> List<A> synchroList() {
    return synchroList(new ArrayList<A>());
  }

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

  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 Runnable toRunnable(final Object o) {
    if (o instanceof Runnable)
      return (Runnable) o;
    if (o instanceof String)
      throw fail("callF_legacy");
    return new Runnable() {

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

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

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

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

  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) {
      printStackTrace(__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) {
      printStackTrace(__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();
      }
    } catch (Throwable __e) {
      printStackTrace(__e);
    }
    return null;
  }

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

  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 abstract class VF1<A> implements IVF1<A> {

    public abstract void get(A a);
  }

  public static interface IF0<A> {

    A get();
  }

  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 abstract class F0<A> {

    abstract A get();
  }

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

    void set(A a);

    A get();

    // reified type of value (if available)
    default Class<A> getType() {
      return null;
    }

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

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

  static interface ISetter<A> {

    void set(A a);
  }

  static <A> A set(A o, String field, Object value) {
    if (o == null)
      return null;
    if (o instanceof Class)
      set((Class) o, field, value);
    else
      try {
        Field f = set_findField(o.getClass(), field);
        makeAccessible(f);
        smartSet(f, o, value);
      } catch (Exception e) {
        throw new RuntimeException(e);
      }
    return o;
  }

  static void set(Class c, String field, Object value) {
    if (c == null)
      return;
    try {
      Field f = set_findStaticField(c, field);
      makeAccessible(f);
      smartSet(f, null, value);
    } catch (Exception e) {
      throw new RuntimeException(e);
    }
  }

  static Field set_findStaticField(Class<?> c, String field) {
    Class _c = c;
    do {
      for (Field f : _c.getDeclaredFields()) if (f.getName().equals(field) && (f.getModifiers() & java.lang.reflect.Modifier.STATIC) != 0)
        return f;
      _c = _c.getSuperclass();
    } while (_c != null);
    throw new RuntimeException("Static field '" + field + "' not found in " + c.getName());
  }

  static Field set_findField(Class<?> c, String field) {
    Class _c = c;
    do {
      for (Field f : _c.getDeclaredFields()) if (f.getName().equals(field))
        return f;
      _c = _c.getSuperclass();
    } while (_c != null);
    throw new RuntimeException("Field '" + field + "' not found in " + c.getName());
  }

  static void set(BitSet bs, int idx) {
    {
      if (bs != null)
        bs.set(idx);
    }
  }

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

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

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

  // pred: char -> bool
  static String takeCharsWhile(String s, Object pred) {
    int i = 0;
    while (i < l(s) && isTrue(callF(pred, s.charAt(i)))) ++i;
    return substring(s, 0, i);
  }

  static String takeCharsWhile(IF1<Character, Boolean> f, String s) {
    return takeCharsWhile(s, f);
  }

  static boolean 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 boolean contains(Rect r, Pt p) {
    return rectContains(r, p);
  }

  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 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 boolean rectContains(int x1, int y1, int w, int h, Pt p) {
    return p.x >= x1 && p.y >= y1 && p.x < x1 + w && p.y < y1 + h;
  }

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

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

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

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

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

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

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

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

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

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

  final static class Rect implements IFieldsToList {

    static final String _fieldOrder = "x y w h";

    int x;

    int y;

    int w;

    int h;

    Rect() {
    }

    Rect(int x, int y, int w, int h) {
      this.h = h;
      this.w = w;
      this.y = y;
      this.x = x;
    }

    public boolean equals(Object o) {
      if (!(o instanceof Rect))
        return false;
      Rect __1 = (Rect) o;
      return x == __1.x && y == __1.y && w == __1.w && h == __1.h;
    }

    public int hashCode() {
      int h = 2543108;
      h = boostHashCombine(h, _hashCode(x));
      h = boostHashCombine(h, _hashCode(y));
      h = boostHashCombine(h, _hashCode(w));
      h = boostHashCombine(h, _hashCode(h));
      return h;
    }

    public Object[] _fieldsToList() {
      return new Object[] { x, y, w, h };
    }

    Rect(Rectangle r) {
      x = r.x;
      y = r.y;
      w = r.width;
      h = r.height;
    }

    Rect(Pt p, int w, int h) {
      this.h = h;
      this.w = w;
      x = p.x;
      y = p.y;
    }

    Rect(Rect r) {
      x = r.x;
      y = r.y;
      w = r.w;
      h = r.h;
    }

    Rectangle getRectangle() {
      return new Rectangle(x, y, w, h);
    }

    public String toString() {
      return x + "," + y + " / " + w + "," + h;
    }

    int x1() {
      return x;
    }

    int y1() {
      return y;
    }

    int x2() {
      return x + w;
    }

    int y2() {
      return y + h;
    }

    boolean contains(Pt p) {
      return contains(p.x, p.y);
    }

    boolean contains(int _x, int _y) {
      return _x >= x && _y >= y && _x < x + w && _y < y + h;
    }

    boolean contains(Rectangle r) {
      return rectContains(this, r);
    }

    boolean empty() {
      return w <= 0 || h <= 0;
    }

    int getWidth() {
      return w;
    }

    int getHeight() {
      return h;
    }
  }

  static class Pt implements Comparable<Pt>, IDoublePt {

    int x, y;

    Pt() {
    }

    Pt(Point p) {
      x = p.x;
      y = p.y;
    }

    Pt(int x, int y) {
      this.y = y;
      this.x = x;
    }

    Point getPoint() {
      return new Point(x, y);
    }

    public boolean equals(Object o) {
      return o instanceof Pt && x == ((Pt) o).x && y == ((Pt) o).y;
    }

    public int hashCode() {
      return boostHashCombine(x, y);
    }

    // compare in scan order
    public int compareTo(Pt p) {
      if (y != p.y)
        return cmp(y, p.y);
      return cmp(x, p.x);
    }

    public String toString() {
      return x + ", " + y;
    }

    double length() {
      return sqrt(x * x + y * y);
    }

    Pt minus(Pt p) {
      return ptMinus(this, p);
    }

    public double x_double() {
      return x;
    }

    public double y_double() {
      return y;
    }
  }

  interface IDoublePt {

    public double x_double();

    public double y_double();
  }

  static int boostHashCombine(int a, int b) {
    return a ^ (b + 0x9e3779b9 + (a << 6) + (a >>> 2));
  // OLD (changed) 2022/3/10: ret a ^ (b + 0x9e3779b9 + (a << 6) + (a >> 2));
  }

  static double sqrt(double x) {
    return Math.sqrt(x);
  }

  static <A> List<A> minus(Collection<A> a, Object... b) {
    Set set = asSet(b);
    List l = new ArrayList();
    for (Object s : unnull(a)) if (!set.contains(s))
      l.add(s);
    return l;
  }

  static BigInteger minus(BigInteger a, BigInteger b) {
    return a.subtract(b);
  }

  static Complex minus(Complex c) {
    return c == null ? null : complex(-c.re(), -c.im());
  }

  static int minus(int a, int b) {
    return a - b;
  }

  static double minus(double a, double b) {
    return a - b;
  }

  static Pt ptMinus(Pt a, Pt b) {
    if (b == null)
      return a;
    return new Pt(a.x - b.x, a.y - b.y);
  }

  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 Complex complex(double re, double im) {
    return new Complex(re, im);
  }

  static Complex complex(double re) {
    return new Complex(re, 0.0);
  }

  static Complex complex(double[] reIm) {
    if (empty(reIm))
      return null;
    if (l(reIm) != 2)
      throw fail("Need 2 doubles to make complex number");
    return complex(reIm[0], reIm[1]);
  }

  static class Complex implements IFieldsToList {

    static final String _fieldOrder = "re im";

    double re;

    double im;

    Complex() {
    }

    Complex(double re, double im) {
      this.im = im;
      this.re = re;
    }

    public boolean equals(Object o) {
      if (!(o instanceof Complex))
        return false;
      Complex __1 = (Complex) o;
      return re == __1.re && im == __1.im;
    }

    public int hashCode() {
      int h = -1679819632;
      h = boostHashCombine(h, _hashCode(re));
      h = boostHashCombine(h, _hashCode(im));
      return h;
    }

    public Object[] _fieldsToList() {
      return new Object[] { re, im };
    }

    double abs() {
      return sqrt(re * re + im * im);
    }

    double re() {
      return re;
    }

    double im() {
      return im;
    }

    final double angle() {
      return phase();
    }

    double phase() {
      return Math.atan2(im, re);
    }

    // angle as 0 to 1
    double fracAngle() {
      return fracNonNeg(angle() / twoPi());
    }

    public String toString() {
      if (im != 0)
        return re == 0 ? im + "i" : re + plusPrefixUnlessMinus(str(im)) + "i";
      else
        return str(re);
    }
  }

  static double fracNonNeg(double d) {
    return frac_nonNeg(d);
  }

  static double twoPi() {
    return Math.PI * 2;
  }

  static String plusPrefixUnlessMinus(String s) {
    return startsWith(s, "-") ? s : "+" + s;
  }

  static double frac_nonNeg(double d) {
    return mod(d, 1);
  }

  // better modulo that gives positive numbers always
  static int mod(int n, int m) {
    return (n % m + m) % m;
  }

  static long mod(long n, long m) {
    return (n % m + m) % m;
  }

  static BigInteger mod(BigInteger n, int m) {
    return n.mod(bigint(m));
  }

  static double mod(double n, double m) {
    return (n % m + m) % m;
  }

  static BigInteger bigint(String s) {
    return new BigInteger(s);
  }

  static BigInteger bigint(long l) {
    return BigInteger.valueOf(l);
  }
}