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 x30_pkg.x30_util;
import static x30_pkg.x30_util.VF1;
import static x30_pkg.x30_util.getOpt;
import static x30_pkg.x30_util.setOpt;
import static x30_pkg.x30_util.callOpt;
import static x30_pkg.x30_util.newWeakHashMap;
import static x30_pkg.x30_util.newDangerousWeakHashMap;
import static x30_pkg.x30_util.get;
import static x30_pkg.x30_util.get_raw;
import static x30_pkg.x30_util.assertTrue;
import static x30_pkg.x30_util.isHeadless;
import static x30_pkg.x30_util.isAndroid;
import static x30_pkg.x30_util.isTrue;
import x30_pkg.x30_util.DynamicObject;
import loadableUtils.utils;
import static loadableUtils.utils._threadInfo;
import static loadableUtils.utils._threadInheritInfo;
import static loadableUtils.utils.dm_current_mandatory;
import static loadableUtils.utils.match;
import static loadableUtils.utils.getField;
import static loadableUtils.utils.vm_generalIdentityHashSet;
import static loadableUtils.utils.vm_generalHashMap;
import static loadableUtils.utils.vm_generalWeakSubMap;
import static loadableUtils.utils.bindToComponent;
import static loadableUtils.utils.struct;
import static loadableUtils.utils.structure;
import static loadableUtils.utils.structureToPrintWriter;
import static loadableUtils.utils.loadPage;
import static loadableUtils.utils.loadPage_utf8;
import static loadableUtils.utils.loadPageSilently;
import static loadableUtils.utils.loadSnippet;
import static loadableUtils.utils.componentPopupMenu;
import static loadableUtils.utils.tablePopupMenu;
import static loadableUtils.utils.tablePopupMenuFirst;
import static loadableUtils.utils.sexyTableWithoutDrag;
import static loadableUtils.utils.dm_current_generic;
import static loadableUtils.utils.cset;
import static loadableUtils.utils.DynamicObject_loading;
import static loadableUtils.utils.concepts_unlisted;
import static loadableUtils.utils.dynamicObjectIsLoading;
import static loadableUtils.utils.rethrow;
import loadableUtils.utils.F0;
import loadableUtils.utils.F1;
import loadableUtils.utils.IF0;
import loadableUtils.utils.IF1;
import loadableUtils.utils.IVF1;
import loadableUtils.utils.Matches;
import loadableUtils.utils.BetterLabel;
import loadableUtils.utils.SingleComponentPanel;
import loadableUtils.utils.Q;
import loadableUtils.utils.ImageSurface;
import loadableUtils.utils.structure_Data;
import loadableUtils.utils.RGBImage;
import loadableUtils.utils.RGB;
import loadableUtils.utils.BWImage;
import loadableUtils.utils.MakesBufferedImage;
import loadableUtils.utils.MultiSet;
import loadableUtils.utils.Concept;
import loadableUtils.utils.Concepts;
import loadableUtils.utils.IConceptIndex;
import loadableUtils.utils.IConceptCounter;
import loadableUtils.utils.IterableIterator;
import loadableUtils.utils.IFieldIndex;
import loadableUtils.utils.PersistableThrowable;
import loadableUtils.utils.DynModule;
import loadableUtils.utils.GlobalID;
import loadableUtils.utils.Rect;
import loadableUtils.utils.Pt;
import static loadableUtils.utils.db_mainConcepts;
import static loadableUtils.utils.fixNewLines;
import static loadableUtils.utils.sfu;
import static loadableUtils.utils.getExceptionCause;
import static loadableUtils.utils.joinWithSpace;
import static loadableUtils.utils.callF;
import static loadableUtils.utils.javaTok;
import static loadableUtils.utils.interceptPrintInThisThread;
import static loadableUtils.utils.jlabel;
import static loadableUtils.utils.join;
import static loadableUtils.utils.isAWTThread;
import static loadableUtils.utils.set;
import static loadableUtils.utils.call;
import static loadableUtils.utils.fail;
import static loadableUtils.utils.print;
import static loadableUtils.utils.doLater;
import static loadableUtils.utils.cget;
import static loadableUtils.utils.db;
import loadableUtils.utils.LongRange;
import loadableUtils.utils.IntRange;
import loadableUtils.utils.MultiMap;
import loadableUtils.utils.Meta;
import loadableUtils.utils.SimpleLiveValue;
import loadableUtils.utils.Matrix;
import loadableUtils.utils.IRef;
import loadableUtils.utils.F2;
import loadableUtils.utils.RandomAccessAbstractList;
import loadableUtils.utils.IBWIntegralImage;
import loadableUtils.utils.Producer;
import loadableUtils.utils.IntBuffer;
import loadableUtils.utils.AbstractMatrix;
import loadableUtils.utils.OKOrError;
import loadableUtils.utils.IMeta;
import loadableUtils.utils.LiveValue;
import loadableUtils.utils.Timestamp;
import loadableUtils.utils.DoubleRect;
import loadableUtils.utils.Complex;
import loadableUtils.utils.Either;
import loadableUtils.utils.Steppable;
import loadableUtils.utils.T3;
import loadableUtils.utils.Swingable;
import loadableUtils.utils.JavaXClassLoader;
import loadableUtils.utils.Average;
import loadableUtils.utils.BWIntegralImage;
import loadableUtils.utils.DoubleRange;
import loadableUtils.utils.Seconds;
import loadableUtils.utils.Scored;
import static loadableUtils.utils.score;
import static loadableUtils.utils.stepAll;
import static loadableUtils.utils.isRunnableX;
import static loadableUtils.utils.wrappedTextArea;
import static loadableUtils.utils.infoMessage;
import static loadableUtils.utils.brightnessToRGBA;
import static loadableUtils.utils.sorted;
import static loadableUtils.utils.rcallOpt;
import static loadableUtils.utils.childrenOfType;
import static loadableUtils.utils.unCurlyBracket;
import static loadableUtils.utils.isA;
import static loadableUtils.utils.nanoTime;
import static loadableUtils.utils.b;
import static loadableUtils.utils.ewicOneOf;
import static loadableUtils.utils.jCenteredSection;
import static loadableUtils.utils.dm_fieldLabel;
import static loadableUtils.utils.n;
import static loadableUtils.utils.abs;
import static loadableUtils.utils.prepareProgramFile;
import static loadableUtils.utils.callMain;
import static loadableUtils.utils.evalJava_prep;
import static loadableUtils.utils.caseInsensitiveComparator;
import static loadableUtils.utils.getComponents;
import static loadableUtils.utils.rep;
import static loadableUtils.utils.area;
import static loadableUtils.utils.add;
import static loadableUtils.utils.singleComponentPanel;
import static loadableUtils.utils.simpleDateFormat_local;
import static loadableUtils.utils.withMargin;
import static loadableUtils.utils.addActionListener;
import static loadableUtils.utils.hasMethod;
import static loadableUtils.utils.enterKeyListener;
import static loadableUtils.utils.countIteratorToList;
import static loadableUtils.utils.setFrameIconLater;
import static loadableUtils.utils.intersectRects;
import static loadableUtils.utils.setSCPComponent;
import static loadableUtils.utils.withLeftMargin;
import static loadableUtils.utils.jPopDownButton_noText;
import static loadableUtils.utils.swingLater;
import static loadableUtils.utils.currentImage;
import static loadableUtils.utils.boolOptParam;
import static loadableUtils.utils.getOptMC;
import static loadableUtils.utils.setImage;
import static loadableUtils.utils.regexp;
import static loadableUtils.utils.setFrameTitle;
import static loadableUtils.utils._inCore;
import static loadableUtils.utils.getScreenWidth;
import static loadableUtils.utils.tsNow;
import static loadableUtils.utils.boundsOnScreen;
import static loadableUtils.utils.formatFunctionCall;
import static loadableUtils.utils.dm_reload;
import static loadableUtils.utils.isIdentifier;
import static loadableUtils.utils.getSnippetTitle;
import static loadableUtils.utils.jFullCenter;
import static loadableUtils.utils.dm_calculatedLiveValue;
import static loadableUtils.utils.dm_fieldCheckBox;
import static loadableUtils.utils.classNamesInJarOrDir;
import static loadableUtils.utils.scaffoldingEnabled;
import static loadableUtils.utils.indent;
import static loadableUtils.utils.infoBox;
import static loadableUtils.utils.toSeconds;
import static loadableUtils.utils.rect;
import static loadableUtils.utils.cleanUp;
import static loadableUtils.utils.dm_stem;
import static loadableUtils.utils.forEach;
import static loadableUtils.utils.disposeWindow;
import static loadableUtils.utils.moveToTopRightCorner;
import static loadableUtils.utils.stdcompare;
import static loadableUtils.utils.centerAndEast;
import static loadableUtils.utils.metaMapPut;
import static loadableUtils.utils.makeFrame;
import static loadableUtils.utils.okOrError;
import static loadableUtils.utils.setDoubleBuffered;
import static loadableUtils.utils.asVirtualList;
import static loadableUtils.utils.bufferedImage;
import static loadableUtils.utils.mapToObjectArray;
import static loadableUtils.utils.maximumSafeArraySize;
import static loadableUtils.utils.dm_q;
import static loadableUtils.utils.withLeftAndRightMargin;
import static loadableUtils.utils.childOfType;
import static loadableUtils.utils.shortName;
import static loadableUtils.utils.findTranslators2;
import static loadableUtils.utils.getFieldType;
import static loadableUtils.utils.emptyIterableIterator;
import static loadableUtils.utils.flattenArray2;
import static loadableUtils.utils.formatDouble;
import static loadableUtils.utils.getParent;
import static loadableUtils.utils.strOrEmpty;
import static loadableUtils.utils.shorten_str;
import static loadableUtils.utils.run;
import static loadableUtils.utils.has;
import static loadableUtils.utils.last;
import static loadableUtils.utils.caseInsensitiveSet;
import static loadableUtils.utils.checkCondition;
import static loadableUtils.utils.warn;
import static loadableUtils.utils.distance;
import static loadableUtils.utils.jrightAlignedLine;
import static loadableUtils.utils.toRect;
import static loadableUtils.utils.synchroSet;
import static loadableUtils.utils.formatDouble_significant2;
import static loadableUtils.utils.addIfNotNull;
import static loadableUtils.utils.isString;
import static loadableUtils.utils.installTimer;
import static loadableUtils.utils.setAdd;
import static loadableUtils.utils.clipBufferedImage;
import static loadableUtils.utils.formatDouble1;
import static loadableUtils.utils.setText;
import static loadableUtils.utils.vmBus_timerStarted;
import static loadableUtils.utils.splitAtSpace;
import static loadableUtils.utils.getBounds;
import static loadableUtils.utils.northAndCenterWithMargin;
import static loadableUtils.utils.getAndClearList;
import static loadableUtils.utils.loadTextFileResource;
import static loadableUtils.utils.selectedItem;
import static loadableUtils.utils.isSpaceEtc;
import static loadableUtils.utils.joinSubList;
import static loadableUtils.utils.onSelectedItem;
import static loadableUtils.utils.muricaCredentials;
import static loadableUtils.utils.onUpdate;
import static loadableUtils.utils.hotwire_copyOver;
import static loadableUtils.utils.replace;
import static loadableUtils.utils.withTypeWriterFont;
import static loadableUtils.utils.printWithMS;
import static loadableUtils.utils.setSplitPaneOnFirstShowing;
import static loadableUtils.utils.format;
import static loadableUtils.utils.heightForWidth;
import static loadableUtils.utils.hsplit;
import static loadableUtils.utils.changeListener;
import static loadableUtils.utils.containsNewLine;
import static loadableUtils.utils.centerAndEastWithMargin;
import static loadableUtils.utils.getFrame;
import static loadableUtils.utils.countIterator_exclusive;
import static loadableUtils.utils.centerAndSouth;
import static loadableUtils.utils.jhsplit;
import static loadableUtils.utils.dm_fieldLiveValue;
import static loadableUtils.utils.findAllFiles_noDirs;
import static loadableUtils.utils.toObjectArray;
import static loadableUtils.utils.rectFromPoints;
import static loadableUtils.utils.runnableThread;
import static loadableUtils.utils.toolTip;
import static loadableUtils.utils.firstToUpper;
import static loadableUtils.utils.allScreenBounds;
import static loadableUtils.utils.findClass_fullName;
import static loadableUtils.utils.rCallOnSelectedListItem;
import static loadableUtils.utils.withBottomMargin;
import static loadableUtils.utils.typeWriterFont;
import static loadableUtils.utils.javaCompile_overInternalBot;
import static loadableUtils.utils.jscroll_centered;
import static loadableUtils.utils.parentFile;
import static loadableUtils.utils.listSet;
import static loadableUtils.utils.hfulltag;
import static loadableUtils.utils.getCanonicalPath;
import static loadableUtils.utils.dm_rEnter;
import static loadableUtils.utils.reTok;
import static loadableUtils.utils.toString;
import static loadableUtils.utils.callCalc;
import static loadableUtils.utils.mapI_if1;
import static loadableUtils.utils.squareBracket;
import static loadableUtils.utils.isQuoted;
import static loadableUtils.utils.applyDefaultMargin;
import static loadableUtils.utils.isDigit;
import static loadableUtils.utils.dm_callOS;
import static loadableUtils.utils.regionMatches;
import static loadableUtils.utils.warnIfOddCount;
import static loadableUtils.utils.logQuoted;
import static loadableUtils.utils.loadLibraries;
import static loadableUtils.utils.dm_callOSOpt;
import static loadableUtils.utils.bindLiveValueListenerToComponent;
import static loadableUtils.utils.getPreferredWidth;
import static loadableUtils.utils.screenBounds;
import static loadableUtils.utils.toRectangle;
import static loadableUtils.utils.allMethodNames;
import static loadableUtils.utils.widthForHeight;
import static loadableUtils.utils.centerLabel;
import static loadableUtils.utils.jLiveValueLabel;
import static loadableUtils.utils.shortClassName_dropNumberPrefix;
import static loadableUtils.utils.identityHashCode;
import static loadableUtils.utils.appendToFileBaseName;
import static loadableUtils.utils.jbutton;
import static loadableUtils.utils.addDyn;
import static loadableUtils.utils.setEnabled;
import static loadableUtils.utils.functionCall;
import static loadableUtils.utils.javaTokForStructure;
import static loadableUtils.utils.isCISet;
import static loadableUtils.utils.northAndCenter;
import static loadableUtils.utils.jline;
import static loadableUtils.utils.toMS;
import static loadableUtils.utils.cancelTimer;
import static loadableUtils.utils.creator;
import static loadableUtils.utils.vmBus_query;
import static loadableUtils.utils.change;
import static loadableUtils.utils.assertEquals;
import static loadableUtils.utils.clearAllTokens;
import static loadableUtils.utils.toPath;
import static loadableUtils.utils.getPreferredSize;
import static loadableUtils.utils.unicode_downPointingTriangle;
import static loadableUtils.utils.jLiveValueCheckBox;
import static loadableUtils.utils.md5;
import static loadableUtils.utils.getBorder;
import static loadableUtils.utils.getLookAndFeel;
import static loadableUtils.utils.renderFileInfo;
import static loadableUtils.utils.jCheckBoxMenuItem;
import static loadableUtils.utils.appendToFile;
import static loadableUtils.utils.find;
import static loadableUtils.utils.jenableUndoRedo;
import static loadableUtils.utils.setChecked;
import static loadableUtils.utils.setFont;
import static loadableUtils.utils.syncList;
import static loadableUtils.utils.takeFirst;
import static loadableUtils.utils.isEditableComboBox;
import static loadableUtils.utils.plus;
import static loadableUtils.utils.dm_watchField;
import static loadableUtils.utils.fillJPopupMenu;
import static loadableUtils.utils.hotwire_makeClassLoader;
import static loadableUtils.utils.ifloor;
import static loadableUtils.utils.blend;
import static loadableUtils.utils.indexOf;
import static loadableUtils.utils.repeat;
import static loadableUtils.utils.structureForUser;
import static loadableUtils.utils.ok;
import static loadableUtils.utils.jCheckBox;
import static loadableUtils.utils.toMS_int;
import static loadableUtils.utils.asArray;
import static loadableUtils.utils.pt;
import static loadableUtils.utils.showText;
import static loadableUtils.utils.setDefaultClassFinder;
import static loadableUtils.utils.isCurlyBracketed;
import static loadableUtils.utils.getBytecodePathForClass;
import static loadableUtils.utils.transpileRaw_makeTranslator;
import static loadableUtils.utils.singular;
import static loadableUtils.utils.minus;
import static loadableUtils.utils.syncAddOrCreate;
import static loadableUtils.utils.fileNameEncode;
import static loadableUtils.utils.reversedList;
import static loadableUtils.utils.intRange;
import static loadableUtils.utils.getScreenHeight;
import static loadableUtils.utils.ratio;
import static loadableUtils.utils.fillRect;
import static loadableUtils.utils.getSelectedItem;
import static loadableUtils.utils.isChecked;
import static loadableUtils.utils.similarEmptyMap;
import static loadableUtils.utils.toFile;
import static loadableUtils.utils.tempAdd;
import static loadableUtils.utils.onMouseDown;
import static loadableUtils.utils.tempDisposeWindow;
import static loadableUtils.utils.pixelCount;
import static loadableUtils.utils.pairA;
import static loadableUtils.utils.dropFirst;
import static loadableUtils.utils.newWeakHashSet;
import static loadableUtils.utils.mod;
import static loadableUtils.utils.squareBracketed;
import static loadableUtils.utils.subByteArray;
import static loadableUtils.utils.findClass;
import static loadableUtils.utils.humanizeFormLabel;
import static loadableUtils.utils.addSuffix;
import static loadableUtils.utils.wrapForSmartAdd;
import static loadableUtils.utils.asSet;
import static loadableUtils.utils.autoFrameTitle;
import static loadableUtils.utils.westCenterAndEast;
import static loadableUtils.utils.shootScreen2;
import static loadableUtils.utils.filter;
import static loadableUtils.utils.syncLinkedHashSet;
import static loadableUtils.utils.mapPut;
import static loadableUtils.utils.onChange;
import static loadableUtils.utils.isInQ;
import static loadableUtils.utils.uniqueFileNameUsingMD5_80_v2;
import static loadableUtils.utils.isMenuSeparatorIndicator;
import static loadableUtils.utils.applyMargin;
import static loadableUtils.utils.withTopMargin;
import static loadableUtils.utils.dirOfFile;
import static loadableUtils.utils.error;
import static loadableUtils.utils.setBackground;
import static loadableUtils.utils.sysNow;
import static loadableUtils.utils.elapsedSeconds;
import static loadableUtils.utils.bigint;
import static loadableUtils.utils.hotwire;
import static loadableUtils.utils.metaGet;
import static loadableUtils.utils.heldInstance;
import static loadableUtils.utils.nestedIterator;
import loadableUtils.utils.Pair;
import loadableUtils.utils.BetterThreadLocal;
import loadableUtils.utils.IBWImage;
import loadableUtils.utils.WidthAndHeight;
import loadableUtils.utils.Enterable;
import loadableUtils.utils.SimpleCRUD_v2;
import static loadableUtils.utils._MethodCache;
import static loadableUtils.utils.defaultMargin;
import static loadableUtils.utils.showForm_makeFrame;
import loadableUtils.utils.Decolorizer;
import javax.swing.border.*;
import com.github.sarxos.webcam.*;
import java.text.NumberFormat;
import javax.imageio.metadata.*;
import javax.imageio.stream.*;
import java.text.SimpleDateFormat;
import java.nio.charset.Charset;
import java.nio.file.*;
import static java.nio.file.StandardWatchEventKinds.*;
import org.fife.ui.autocomplete.*;
import org.fife.rsta.ui.CollapsibleSectionPanel;
import org.fife.rsta.ui.GoToDialog;
import org.fife.rsta.ui.SizeGripIcon;
import org.fife.rsta.ui.search.FindDialog;
import org.fife.rsta.ui.search.ReplaceDialog;
import org.fife.rsta.ui.search.ReplaceToolBar;
import org.fife.rsta.ui.search.SearchEvent;
import org.fife.rsta.ui.search.SearchListener;
import org.fife.rsta.ui.search.FindToolBar;
import org.fife.ui.rsyntaxtextarea.ErrorStrip;
import org.fife.ui.rsyntaxtextarea.RSyntaxTextArea;
import org.fife.ui.rsyntaxtextarea.SyntaxConstants;
import org.fife.ui.rtextarea.RTextScrollPane;
import org.fife.ui.rtextarea.SearchContext;
import org.fife.ui.rtextarea.SearchEngine;
import org.fife.ui.rtextarea.SearchResult;
import java.awt.datatransfer.StringSelection;
import org.fife.ui.rsyntaxtextarea.*;
import java.awt.geom.*;
import java.awt.datatransfer.*;
import java.awt.geom.AffineTransform;
import java.text.*;

class main {

  static public String programID;

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

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

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

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

  static public class GazelleScreenCam extends DynModule {

    volatile public boolean enabled = true;

    transient public JPanel buttons;

    public void setEnabled(boolean b) {
      setField("enabled", b);
    }

    public JComponent visualize_enabled() {
      return dm_checkBox("enabled");
    }

    public int pixelRows = 128, colors = 8;

    public String script = "64p 8c gradientImage";

    public String newScript;

    public String screenCamScript;

    public String selectedTab;

    public String javaCode;

    public String recognizerScript;

    public boolean horizontalLayout = false;

    public int fpsTarget = 20;

    public String webCamName;

    public boolean webCamAccessEnabled = true;

    public WatchTarget watchTarget;

    public G22_TestScreenPanel testScreen = new G22_TestScreenPanel();

    transient public ImageSurface isPosterized;

    transient public ScreenCamStream imageStream = new ScreenCamStream();

    transient public Gazelle22_ImageToRegions imageToRegions_finished;

    transient public DoubleFPSCounter fpsCounter = new DoubleFPSCounter();

    transient public int fps;

    transient public WatchTargetSelector watchTargetSelector;

    transient public RollingAverage remainingMSPerFrame = new RollingAverage();

    transient public int remainingMS;

    transient public FunctionTimings<String> functionTimings = new FunctionTimings();

    transient public ReliableSingleThread rstRunScript = dm_rst(me(), new Runnable() {

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

      public String toString() {
        return "_runScript();";
      }
    });

    transient public JGazelleVScriptRunner scriptRunner;

    transient public UIURLSystem uiURLs;

    transient public JComboBox<Webcam> cbWebCam;

    transient public SingleComponentPanel scpWebCamImage;

    transient public WebcamPanel webCamPanel;

    transient public JLeftArrowScriptIDE screenCamScriptIDE;

    transient public GazelleV_LeftArrowScript.Script runningScreenCamScript;

    transient public Concepts concepts;

    public String uiURL = "Main Tabs";

    transient public FileWatchService fileWatcher;

    transient public SimpleCRUD_v2<Label> labelCRUD;

    transient public SimpleCRUD_v2<GalleryImage> imageCRUD;

    transient public JComponent imageCRUDVis;

    transient public JGallery gallery;

    transient public JComponent galleryComponent;

    transient public SimpleCRUD_v2<G22Challenge> challengeCRUD;

    transient public SingleComponentPanel scpChallengePanel, scpChallengeCode;

    transient public SimpleCRUD_v2<G22RecognizerScript> recognizerCRUD;

    transient public FlexibleRateTimer screenCamTimer;

    transient public SingleComponentPanel scpMain;

    transient public JTabbedPane mainTabs;

    transient public boolean showRegionsAsOutline = true;

    transient public JComponent watchScreenPane;

    transient public String screenCamRecognitionOutput;

    transient public G22Utils g22utils = new G22Utils();

    transient public BackgroundProcessesUI backgroundProcessesUI;

    transient public BackgroundProcessesUI.Entry bgScreenCam = new BackgroundProcessesUI.Entry("Screen Cam").menuItem(jMenuItem("Screen Cam", new Runnable() {

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

      public String toString() {
        return "showScreenCam();";
      }
    }));

    transient public BackgroundProcessesUI.Entry bgWebCam = new BackgroundProcessesUI.Entry("Web Cam").menuItem(jMenuItem("Web Cam", new Runnable() {

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

      public String toString() {
        return "showWebCam();";
      }
    }));

    public void start() {
      try {
        super.start();
        testScreen.onChange(() -> change());
        dm_onFieldChange("horizontalLayout", new Runnable() {

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

          public String toString() {
            return "dm_reload();";
          }
        });
        if (concepts == null) {
          printWithMS("Starting DB");
          db();
          concepts = db_mainConcepts();
        } else
          assertSame(concepts, db_mainConcepts());
        concepts.quietSave = true;
        indexConceptField(concepts, GalleryImage.class, "path");
        indexConceptField(concepts, Example.class, "item");
        g22utils.modifyLeftArrowParser = __13 -> modifyLeftArrowParser(__13);
        g22utils.basicParserTest();
        onConceptChanges(concepts, () -> {
          {
            if (labelCRUD != null)
              labelCRUD.updateEnclosingTabTitle();
          }
          updateEnclosingTabTitleWithCount(galleryComponent, countConcepts(GalleryImage.class));
        });
        uiURLs = new UIURLSystem(me(), dm_fieldLiveValue("uiURL"));
        uiURLs.addPreferredUIURL("Main Tabs");
        backgroundProcessesUI = new BackgroundProcessesUI();
        dm_watchFieldAndNow("enabled", () -> backgroundProcessesUI.addOrRemove(enabled, bgScreenCam));
        scriptRunner = new JGazelleVScriptRunner(dm_fieldLiveValue("script", me()));
        printWithMS("Making image stream");
        imageStream.onNewElement(img -> {
          fpsCounter.inc();
          setField("fps", iround(fpsCounter.get()));
          assertTrue("meta", getMetaSrc(img) instanceof ScreenShotMeta);
          Gazelle22_ImageToRegions itr = new Gazelle22_ImageToRegions(functionTimings, img, new SnPSettings(pixelRows, colors));
          itr.run();
          imageToRegions_finished = itr;
          if (shouldRunScript())
            rstRunScript.go();
          if (screenCamScriptIDE != null && screenCamScriptIDE.visible())
            try {
              g22_runPostAnalysisLeftArrowScript(itr, runningScreenCamScript);
            } catch (Throwable e) {
              printStackTrace(e);
              screenCamScriptIDE.showRuntimeError(e);
            }
          String text = nRegions(itr.regions.regionCount());
          setField("screenCamRecognitionOutput", text);
          g22_renderPosterizedHighlightedImage(isPosterized, itr, showRegionsAsOutline);
        });
        watchTargetSelector = new WatchTargetSelector();
        printWithMS("Starting screen cam");
        ownResource(screenCamTimer = new FlexibleRateTimer(fpsTarget, new Runnable() {

          public void run() {
            try {
              AutoCloseable __8 = enter();
              try {
                if (!enabled)
                  return;
                {
                  if (watchTargetSelector != null)
                    watchTargetSelector.updateScreenCount();
                }
                Timestamp deadline = tsNowPlusMS(1000 / fpsTarget);
                {
                  if (watchTarget != null)
                    watchTarget.configureScreenCamStream(imageStream);
                }
                imageStream.step();
                long remaining = deadline.minus(tsNow());
                remainingMSPerFrame.add(remaining);
                setField("remainingMS", iround(remainingMSPerFrame.get()));
              } finally {
                _close(__8);
              }
            } catch (Exception __e) {
              throw rethrow(__e);
            }
          }

          public String toString() {
            return "temp enter(); \r\n      if (!enabled) return;\r\n      watchTargetSelector?.updat...";
          }
        }));
        screenCamTimer.start();
        dm_onFieldChange("fpsTarget", () -> screenCamTimer.setFrequencyImmediately(fpsTarget));
        printWithMS("Starting dir watcher");
        startDirWatcher();
        printWithMS("Gathering images from disk");
        for (var f : allImageFiles(galleryDir())) addToGallery(f);
        printWithMS("Got dem images");
        transpileRaw_makeTranslator = () -> hotwire("#7");
      } catch (Exception __e) {
        throw rethrow(__e);
      }
    }

    public void startDirWatcher() {
      fileWatcher = new FileWatchService();
      fileWatcher.addRecursiveListener(picturesDir(), file -> {
        if (!isImageFile(file))
          return;
        addToGallery(file);
      });
    }

    public JComponent visualize() {
      gallery = new JGallery();
      galleryComponent = gallery.visualize();
      new AWTOnConceptChanges(concepts, galleryComponent, () -> {
        gallery.setImageFiles(map(list(GalleryImage.class), i -> i.path));
      }).install();
      isPosterized = g22utils.stdImageSurface();
      labelCRUD = new SimpleCRUD_v2(concepts, Label.class);
      labelCRUD.hideFields("globalID");
      labelCRUD.addCountToEnclosingTab(true);
      labelCRUD.itemToMap_inner2 = l -> litorderedmap("Name", l.name, "# Examples", n2(countConcepts(concepts, Example.class, "label", l)));
      imageCRUD = new SimpleCRUD_v2(concepts, GalleryImage.class);
      imageCRUD.addCountToEnclosingTab(true);
      imageCRUD.itemToMap_inner2 = img -> litorderedmap("File", fileName(img.path), "Folder", dirPath(img.path));
      imageCRUDVis = imageCRUD.visualize();
      imageCRUD.addButton(jPopDownButton_noText("Forget missing images", runnableThread(new Runnable() {

        public void run() {
          try {
            AutoCloseable __18 = enter();
            try {
              forgetMissingImages();
            } finally {
              _close(__18);
            }
          } catch (Exception __e) {
            throw rethrow(__e);
          }
        }

        public String toString() {
          return "temp enter();  forgetMissingImages();";
        }
      })));
      var studyPanel = new StudyPanel();
      watchScreenPane = borderlessScrollPane(jHigherScrollPane(jfullcenter(vstack(withLeftAndRightMargin(hstack(dm_rcheckBox("enabled", "Watch"), watchTargetSelector.visualize(), jlabel(" in "), withLabelToTheRight("colors @ ", dm_spinner("colors", 2, 256)), withLabelToTheRight("p", dm_powersOfTwoSpinner("pixelRows", 512)))), verticalStrut(2), withSideMargins(centerAndEastWithMargin(dm_fieldLabel("screenCamRecognitionOutput"), dm_transientCalculatedToolTip(() -> speedInfo_long(), rightAlignLabel(dm_transientCalculatedLabel(() -> speedInfo())))))))));
      initUIURLs();
      mainTabs = scrollingTabs(jTopOrLeftTabs(horizontalLayout, "Screen Cam", jOnDemand(() -> screenCamPanel()), new WithToolTip("Study", "Here you can analyze gallery images"), withTopAndBottomMargin(studyPanel.visualize()), new WithToolTip("Java", "Write & run actual Java code"), withBottomMargin(jOnDemand(() -> javaPanel())), new WithToolTip("Gallery", "Gallery view with preview images"), withBottomMargin(withRightAlignedButtons(galleryComponent, "Gallery CRUD", new Runnable() {

        public void run() {
          try {
            uiURLs.showUIURL("Gallery CRUD");
          } catch (Exception __e) {
            throw rethrow(__e);
          }
        }

        public String toString() {
          return "showUIURL(\"Gallery CRUD\")";
        }
      })), new WithToolTip("Challenges", "Gazelle's self-tests"), challengesPanel()));
      challengeCRUD.update();
      addUIURLToMainTabs("Left Arrow Script");
      addTabs(mainTabs, new WithToolTip("Databases", "Choose the Gazelle database to use"), databasesPanel());
      for (String tab : tabNames(mainTabs)) {
        var _tab_14 = dropTrailingBracketedCount(tab);
        uiURLs.put(_tab_14, () -> {
          int i = indexOfTabNameWithoutTrailingCount(mainTabs, _tab_14);
          if (i < 0)
            return jcenteredlabel("Hmm. Tab not found");
          selectTab(mainTabs, i);
          return mainTabs;
        });
      }
      var cbEnabled = toolTip("Switch screen cam on or off", dm_checkBox("enabled", ""));
      var lblScreenCam = setToolTip("Show scaled down and color-reduced screen image", jlabel("Screen Cam"));
      tabComponentClickFixer(lblScreenCam);
      var screenCamTab = hstackWithSpacing(cbEnabled, lblScreenCam);
      replaceTabTitleComponent(mainTabs, "Screen Cam", screenCamTab);
      labelCRUD.update();
      imageCRUD.update();
      persistSelectedTabAsLiveValue(mainTabs, dm_fieldLiveValue("selectedTab"));
      var urlBar = uiURLs.urlBar();
      focusOnFirstShow(urlBar);
      setToolTip(uiURLs.comboBox, "UI navigation system (partially populated)");
      scpMain = singleComponentPanel();
      uiURLs.scp(scpMain);
      uiURLs.showUIURL(uiURL);
      var lblDB = toolTip("Currently selected database (" + f2s(concepts.conceptsDir()) + ")", jSimpleLabel(conceptsDirName()));
      componentPopupMenuItems(lblDB, "Manage or switch databases...", runnableThread(new Runnable() {

        public void run() {
          try {
            uiURLs.showUIURL("Databases");
          } catch (Exception __e) {
            throw rethrow(__e);
          }
        }

        public String toString() {
          return "showUIURL(\"Databases\")";
        }
      }));
      var vis = northAndCenter(withSideAndTopMargin(westCenterAndEast(withLabelToTheRight(lblDB, "| "), urlBar, withLeftMargin(backgroundProcessesUI.shortLabel()))), scpMain);
      return vis;
    }

    public JComponent screenCamPanel() {
      return centerAndSouthOrEast(horizontalLayout, withTools(isPosterized), watchScreenPane);
    }

    public JComponent screenCamPlusScriptPanel() {
      AutoCloseable __9 = enter();
      try {
        print("screenCamPlusScriptPanel");
        try {
          var ide = screenCamScriptIDE = leftArrowScriptIDE();
          ide.runButtonShouldBeEnabled = () -> eq(getText(ide.btnRun), "Stop") || ide.runButtonShouldBeEnabled_base();
          ide.runScript = () -> {
            if (eq(getText(ide.btnRun), "Stop"))
              runningScreenCamScript = null;
            else {
              runningScreenCamScript = screenCamScriptIDE.parsedScript();
              ide.showStatus("Running");
            }
            setText(ide.btnRun, runningScreenCamScript == null ? "Run" : "Stop");
          };
          return centerAndSouthOrEast(horizontalLayout, jhsplit(jscroll_centered_borderless(isPosterized), screenCamScriptIDE.lvScript(dm_fieldLiveValue("screenCamScript")).visualize()), watchScreenPane);
        } catch (Throwable e) {
          print(e);
          throw rethrow(e);
        }
      } finally {
        _close(__9);
      }
    }

    public String speedInfo() {
      return "FPS " + fps + " idle " + remainingMS + " ms";
    }

    public String speedInfo_long() {
      return "Screen cam running at " + nFrames(fps) + "/second. " + n2(remainingMS) + " ms remaining per frame in first core" + " (of targeted " + fpsTarget + " FPS)";
    }

    public boolean useErrorHandling() {
      return false;
    }

    public String renderFunctionTimings() {
      return lines(ciSorted(map(functionTimings.get(), (f, avg) -> firstToUpper(f) + ": " + n2(iround(nsToMicroseconds(avg.get()))) + " " + microSymbol() + "s (" + n2(iround(avg.n())) + ")")));
    }

    transient public long _runScript_idx;

    public void _runScript() {
      scriptRunner.parseAndRunOn(imageToRegions_finished.ii);
    }

    public boolean shouldRunScript() {
      return isShowing(scriptRunner.scpScriptResult);
    }

    public JComponent testScreenPanel() {
      return withSideAndTopMargin(testScreen.visualize());
    }

    public List popDownItems() {
      return ll(jCheckBoxMenuItem_dyn("Horizontal Layout", () -> horizontalLayout, b -> setField("horizontalLayout", b)));
    }

    public void unvisualize() {
    }

    public void resetTimings() {
      functionTimings.reset();
    }

    public JComponent withTools(ImageSurface is) {
      return withTools(jscroll_centered_borderless(is), is);
    }

    public JComponent withTools(JComponent component, ImageSurface is) {
      return centerAndEastWithMargin(component, vstack(verticalStrut(5), jimageButtonScaledToWidth(16, "#1103054", "Save screenshot in gallery", runnableThread(new Runnable() {

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

        public String toString() {
          return "saveScreenshotToGallery();";
        }
      }))));
    }

    public class WatchTargetSelector {

      public JComboBox<WatchTarget> cb = jComboBox();

      public int screenCount, camCount;

      public JComponent visualize() {
        updateList();
        selectItem(cb, watchTarget);
        loadableUtils.utils.onChange(cb, watchTarget -> {
          setField("watchTarget", watchTarget);
        });
        return cb;
      }

      public void updateScreenCount() {
        if (screenCount != screenCount())
          updateList();
      }

      public void updateList() {
        swing(() -> {
          setComboBoxItems(cb, makeWatchTargets());
        });
      }

      public List<WatchTarget> makeWatchTargets() {
        return flattenToList(countIteratorAsList_incl(1, screenCount = screenCount(), i -> new WatchScreen(i)), new WatchMouse(), new WatchScreenWithMouse());
      }
    }

    public class SnPSelector {

      final public SnPSelector setSettings(SnPSettings settings) {
        return settings(settings);
      }

      public SnPSelector settings(SnPSettings settings) {
        this.settings = settings;
        return this;
      }

      final public SnPSettings getSettings() {
        return settings();
      }

      public SnPSettings settings() {
        return settings;
      }

      public SnPSettings settings = new SnPSettings();

      transient public List<Runnable> onChange;

      public SnPSelector onChange(Runnable r) {
        onChange = syncAddOrCreate(onChange, r);
        return this;
      }

      public SnPSelector removeChangeListener(Runnable r) {
        main.remove(onChange, r);
        return this;
      }

      public void change() {
        pcallFAll(onChange);
      }

      public JComponent visualize() {
        var colors = jspinner(settings.colors, 2, 256);
        loadableUtils.utils.onChange(colors, () -> {
          settings.colors = intFromSpinner(colors);
          change();
        });
        var pixelRows = jPowersOfTwoSpinner(512, settings.pixelRows);
        loadableUtils.utils.onChange(pixelRows, () -> {
          settings.pixelRows = intFromSpinner(pixelRows);
          change();
        });
        return hstack(colors, jlabel(" colors @ "), pixelRows, jlabel(" p"));
      }
    }

    public JComponent wrapCRUD(SimpleCRUD_v2 crud) {
      return wrapCRUD(crud, crud.visualize());
    }

    public JComponent wrapCRUD(SimpleCRUD_v2 crud, JComponent vis) {
      return crud == null ? null : withTopAndBottomMargin(jRaisedSection(withMargin(vis)));
    }

    public File galleryDir() {
      return picturesDir(gazelle22_imagesSubDirName());
    }

    public void saveScreenshotToGallery() {
      AutoCloseable __10 = enter();
      try {
        var img = imageStream.get();
        saveImageWithCounter(galleryDir(), "Screenshot", img);
      } finally {
        _close(__10);
      }
    }

    public GalleryImage addToGallery(File imgFile) {
      if (!isImageFile(imgFile))
        return null;
      var img = uniq(concepts, GalleryImage.class, "path", imgFile);
      return img;
    }

    public class StudyPanel {

      public SnPSelector snpSelector = new SnPSelector();

      public GalleryImage image;

      public BufferedImage originalImage;

      public ImageSurface isOriginalWithRegions = g22utils.stdImageSurface();

      public ImageSurface isPosterized = g22utils.stdImageSurface();

      public SingleComponentPanel scp = singleComponentPanel();

      public SingleComponentPanel analysisPanel = singleComponentPanel();

      public SingleComponentPanel scpExampleCRUD = singleComponentPanel();

      public ConceptsComboBox<GalleryImage> cbImage = new ConceptsComboBox<>(concepts, GalleryImage.class);

      public Gazelle22_ImageToRegions itr;

      public int iSelectedRegion;

      public SimpleCRUD_v2<SavedRegion> regionCRUD;

      public SimpleCRUD_v2<Example> exampleCRUD;

      public StudyPanel() {
        cbImage.sortTheList = l -> sortedByComparator(l, (a, b) -> cmpAlphanumIC(fileName(a.path), fileName(b.path)));
        main.onChangeAndNow(cbImage, img -> dm_q(me(), new Runnable() {

          public void run() {
            try {
              image = img;
              scp.setComponent(studyImagePanel());
            } catch (Exception __e) {
              throw rethrow(__e);
            }
          }

          public String toString() {
            return "image = img;\r\n        scp.setComponent(studyImagePanel());";
          }
        }));
        isPosterized.removeAllTools();
        isPosterized.onMousePositionChanged(r_dm_q(me(), () -> regionUpdate()));
        imageSurfaceOnLeftMouseDown(isPosterized, pt -> dm_q(me(), new Runnable() {

          public void run() {
            try {
              chooseRegionAt(pt);
            } catch (Exception __e) {
              throw rethrow(__e);
            }
          }

          public String toString() {
            return "chooseRegionAt(pt)";
          }
        }));
        snpSelector.onChange(r_dm_q(me(), () -> runSnP()));
      }

      public void chooseRegionAt(Pt p) {
        if (itr == null)
          return;
        iSelectedRegion = itr.regions.regionAt(p);
        if (iSelectedRegion > 0) {
          var savedRegion = uniq_returnIfNew(concepts, SavedRegion.class, "image", image, "snpSettings", snpSelector.settings.cloneMe(), "regionIndex", iSelectedRegion);
          if (savedRegion != null) {
            print("Saved new region!");
            var bitMatrix = toScanlineBitMatrix(itr.regions.regionBitMatrix(iSelectedRegion));
            cset(savedRegion, "bitMatrix", bitMatrix);
          }
        }
        regionUpdate();
      }

      public JComponent studyImagePanel() {
        if (image == null)
          return null;
        originalImage = loadImage2(image.path);
        if (originalImage == null)
          return jcenteredlabel("Image not found");
        isOriginalWithRegions.setImage(originalImage);
        iSelectedRegion = 0;
        itr = new Gazelle22_ImageToRegions(functionTimings, originalImage, snpSelector.settings);
        runSnP();
        regionCRUD = new SimpleCRUD_v2<SavedRegion>(concepts, SavedRegion.class);
        regionCRUD.addFilter("image", image);
        regionCRUD.showSearchBar(false).showAddButton(false).showEditButton(false).iconButtons(true);
        regionCRUD.itemToMap_inner2 = region -> {
          var examples = conceptsWhere(concepts, Example.class, "item", region);
          return litorderedmap("Pixels", region.bitMatrix == null ? "-" : n2(region.bitMatrix.pixelCount()), "Labels", joinWithComma(map(examples, e -> e.label)), "Position", region.bitMatrix == null ? "-" : region.bitMatrix.boundingBoxOfTrueBits());
        };
        var regionCRUDComponent = regionCRUD.visualize();
        regionCRUD.onSelectionChanged(() -> updateExampleCRUD());
        return hsplit(jtabs("Image + regions", jscroll_centered_borderless(isOriginalWithRegions), "Posterized", jscroll_centered_borderless(isPosterized)), northAndCenterWithMargin(analysisPanel, hsplit(jCenteredSection("Saved regions", regionCRUDComponent), scpExampleCRUD)));
      }

      public void runSnP() {
        if (itr == null)
          return;
        itr.run();
        regionUpdate();
      }

      public void regionUpdate() {
        if (itr == null)
          return;
        var pixels = itr.posterized.getRGBPixels();
        g22_highlightRegion(pixels, isPosterized, itr, showRegionsAsOutline);
        itr.regions.markRegionInPixelArray(pixels, iSelectedRegion, 0xFFADD8E6);
        var highlighted = bufferedImage(pixels, itr.posterized.getWidth(), itr.posterized.getHeight());
        isPosterized.setImage(highlighted);
        isPosterized.performAutoZoom();
        updateAnalysis();
      }

      public void updateAnalysis() {
      }

      public void updateExampleCRUD() {
        var region = regionCRUD.selected();
        if (region == null) {
          scpExampleCRUD.clear();
          return;
        }
        exampleCRUD = new SimpleCRUD_v2<Example>(concepts, Example.class);
        exampleCRUD.entityName = () -> "label for region";
        exampleCRUD.addFilter("item", region);
        exampleCRUD.showSearchBar(false);
        exampleCRUD.iconButtons(true);
        scpExampleCRUD.set(jCenteredSection("Labels for region", exampleCRUD.visualize()));
      }

      public void importImage() {
        JFileChooser fc = new JFileChooser();
        if (fc.showOpenDialog(cbImage) == JFileChooser.APPROVE_OPTION) {
          File file = fc.getSelectedFile().getAbsoluteFile();
          if (!isImageFile(file)) {
            infoMessage("Not an image file");
            return;
          }
          var img = addToGallery(file);
          waitUntil(250, 5.0, () -> comboBoxContainsItem(cbImage, img));
          setSelectedItem(cbImage, img);
        }
      }

      public JComponent visualize() {
        return jRaisedSection(northAndCenterWithMargins(centerAndEast(withLabel("Study", cbImage), hstack(jlabel(" in "), snpSelector.visualize(), horizontalStrut(10), jPopDownButton_noText("Import image...", runnableThread(new Runnable() {

          public void run() {
            try {
              AutoCloseable __19 = enter();
              try {
                importImage();
              } finally {
                _close(__19);
              }
            } catch (Exception __e) {
              throw rethrow(__e);
            }
          }

          public String toString() {
            return "temp enter();  importImage();";
          }
        })))), scp));
      }
    }

    public void initUIURLs() {
      uiURLs.put("Main Tabs", () -> horizontalLayout ? withMargin(mainTabs) : withSideMargin(mainTabs));
      uiURLs.put("Screen Cam FPS", () -> jFullCenter(vstackWithSpacing(jCenteredLabel("FPS target (frames per second) for screen cam:"), jFullCenter(dm_spinner("fpsTarget", 1, 60)), jCenteredLabel("(You can lower this value if you have a slower computer)"))));
      uiURLs.put("Timings", () -> {
        JTextArea taTimings = jTextArea_noUndo();
        awtEveryAndNow(taTimings, .5, new Runnable() {

          public void run() {
            try {
              setText(taTimings, renderFunctionTimings());
            } catch (Exception __e) {
              throw rethrow(__e);
            }
          }

          public String toString() {
            return "setText(taTimings, renderFunctionTimings())";
          }
        });
        return withRightAlignedButtons(taTimings, "Reset", new Runnable() {

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

          public String toString() {
            return "resetTimings();";
          }
        });
      });
      uiURLs.put("Test Screen", () -> testScreenPanel());
      uiURLs.put("Left Arrow Script", () -> leftArrowScriptPanel());
      uiURLs.put("Settings", () -> settingsPanel());
      uiURLs.put("System Info", () -> systemInfoPanel());
      uiURLs.put("Web Cam", () -> webCamPanel());
      uiURLs.put("Labels", () -> wrapCRUD(labelCRUD));
      uiURLs.put(new WithToolTip("Screen Cam + Linear Script", "Run a simple (linear) Gazelle V script"), () -> withBottomMargin(scriptRunner.scriptAndResultPanel()));
      uiURLs.put(new WithToolTip("Left Arrow Script", "Run a \"left-arrow script\""), () -> withBottomMargin(leftArrowScriptPanel()));
      uiURLs.put("Screen Cam + Script", () -> jOnDemand(() -> screenCamPlusScriptPanel()));
      uiURLs.put(new WithToolTip("Gallery CRUD", "Gallery view with more functions (delete etc)"), () -> wrapCRUD(imageCRUD, imageCRUDVis));
    }

    public JComponent settingsPanel() {
      var cbMinimizeToTray = jCheckBox(isTrue(getOpt(dm_stem(), "minimizeToTray")));
      onUpdate(cbMinimizeToTray, () -> dm_callStem(me(), "setMinimizeToTray", isChecked(cbMinimizeToTray)));
      return jscroll(makeForm3("Minimize to tray", toolTip("Remove Gazelle from task bar when minimized (click Gazelle icon in system tray to reactivate)", cbMinimizeToTray), "Access web cams", dm_checkBox("webCamAccessEnabled")));
    }

    public File gazelleJar() {
      return getBytecodePathForClass(this);
    }

    public JComponent systemInfoPanel() {
      var gazelleJar = gazelleJar();
      var cbMinimizeToTray = jCheckBox(isTrue(getOpt(dm_stem(), "minimizeToTray")));
      onUpdate(cbMinimizeToTray, () -> dm_callStem(me(), "setMinimizeToTray", isChecked(cbMinimizeToTray)));
      return (makeForm3("Java Version", jlabel(javaVersion()), "Gazelle Jar", new JFilePathLabel(gazelleJar).visualize(), "Gazelle Jar Size", str_toMB_oneDigit(fileSize(gazelleJar)), "Compilation Date", jlabel(or2(loadTextFileResource(classLoader(this), "compilation-date.txt"), "unknown")), "Gazelle Count", toolTip("How many Gazelles are running in the world", jLiveValueLabel((LiveValue) dm_callOSOpt("lvComputerCount"))), "Gazelle Database", new JFilePathLabel(concepts.conceptsFile()).visualize(), "Gazelle Database Size", str_toKB(fileSize(concepts.conceptsFile()))));
    }

    public JComponent operatorsPanel() {
      return jcenteredlabel("TODO");
    }

    public JLeftArrowScriptIDE leftArrowScriptIDE() {
      var ide = g22utils.leftArrowIDE();
      ide.withResultPanel();
      return ide;
    }

    public void modifyLeftArrowParser(GazelleV_LeftArrowScriptParser parser) {
      parser.allowTheWorld(me(), mc(), utils.class);
    }

    public JComponent leftArrowScriptPanel() {
      var ide = leftArrowScriptIDE();
      ide.lvScript(dm_fieldLiveValue("newScript"));
      return ide.visualize();
    }

    public JComponent javaPanel() {
      AutoCloseable __11 = enter();
      try {
        var scpResult = singleComponentPanel();
        JMiniJavaIDE ide = new JMiniJavaIDE();
        ide.stringifier(g22utils.stringifier);
        ide.extraClassMembers = script -> {
          List<String> tok = javaTok(script);
          if (contains(tok, "draw"))
            return "\r\n        import java.awt.*;\r\n        import java.awt.image.*;\r\n        \r\n        interface SimpleRenderable {\r\n          void renderOn(Graphics2D g);\r\n        }\r\n        \r\n        static BufferedImage draw(int w, int h, SimpleRenderable r) {\r\n          BufferedImage img = new BufferedImage(w, h, BufferedImage.TYPE_INT_RGB);\r\n          Graphics2D g = img.createGraphics();\r\n          g.setColor(Color.white);\r\n          g.fillRect(0, 0, w, h);\r\n          g.setColor(Color.black);\r\n          r.renderOn(g);\r\n          return img;\r\n        }\r\n      ";
          return "";
        };
        ide.callCompiledObject = o -> {
          Object result = ide.callCompiledObject_base(o);
          if (result instanceof BufferedImage)
            scpResult.set(jscroll_centered_borderless(g22utils.stdImageSurface((BufferedImage) result)));
          return result;
        };
        ide.lvScript(dm_fieldLiveValue("javaCode"));
        return jhsplit(jCenteredSection("Image will show here", scpResult), ide.visualize());
      } finally {
        _close(__11);
      }
    }

    public JComponent webCamPanel() {
      if (cbWebCam == null) {
        var cams = listWebCams();
        cbWebCam = jTypedComboBox(cams, findWebCamByName(cams, webCamName));
      }
      if (scpWebCamImage == null)
        scpWebCamImage = singleComponentPanel();
      return northAndCenterWithMargins(centerAndEastWithMargin(withLabel("Cam", cbWebCam), jline(jbutton("Start", runnableThread(new Runnable() {

        public void run() {
          try {
            AutoCloseable __20 = enter();
            try {
              startWebCam();
            } finally {
              _close(__20);
            }
          } catch (Exception __e) {
            throw rethrow(__e);
          }
        }

        public String toString() {
          return "temp enter();  startWebCam();";
        }
      })), jbutton("Stop", runnableThread(new Runnable() {

        public void run() {
          try {
            AutoCloseable __21 = enter();
            try {
              stopWebCam();
            } finally {
              _close(__21);
            }
          } catch (Exception __e) {
            throw rethrow(__e);
          }
        }

        public String toString() {
          return "temp enter();  stopWebCam();";
        }
      })))), scpWebCamImage);
    }

    public void stopWebCam() {
      if (webCamPanel != null) {
        webCamPanel.stop();
        webCamPanel = null;
        {
          if (scpWebCamImage != null)
            scpWebCamImage.clear();
        }
        backgroundProcessesUI.remove(bgWebCam);
      }
    }

    public void startWebCam() {
      AutoCloseable __12 = tempInfoBox("Starting Web Cam");
      try {
        stopWebCam();
        var cam = getSelectedItem_typed(cbWebCam);
        setField("webCamName", cam == null ? null : cam.getName());
        if (cam != null) {
          scpWebCamImage.set(webCamPanel = new WebcamPanel(cam, true));
          backgroundProcessesUI.add(bgWebCam);
        }
      } finally {
        _close(__12);
      }
    }

    public void forgetMissingImages() {
      int n = l(deleteConcepts(GalleryImage.class, img -> !img.imageExists()));
      infoBox(n == 0 ? "Nothing to forget" : "Forgot " + nImages(n));
    }

    public void addUIURLToMainTabs(String url) {
      swing(() -> {
        if (containsTabNameWithoutTrailingCount(mainTabs, url))
          return;
        if (!uiURLs.hasURL(url)) {
          print("URL not found: " + url);
          return;
        }
        addTab(mainTabs, url, uiURLs.renderUIURL(url));
      });
    }

    public void showScreenCam() {
      uiURLs.showUIURL("Screen Cam");
    }

    public void showWebCam() {
      uiURLs.showUIURL("Web Cam");
    }

    public <A extends G22LeftArrowScript> void setupScriptCRUD(SimpleCRUD_v2<A> crud) {
      crud.updateInterval = 2000;
      crud.useNewChangeHandler(true);
      crud.multiLineField("code");
      crud.makeTextArea = text -> jMinHeight(200, crud.makeTextArea_base(text));
      crud.humanizeFieldNames = false;
      crud.iconButtons(true);
      crud.itemToMap_inner2 = c -> litorderedmap("Description", str(c), "LoC", n2(linesOfCode_javaTok(c.code)));
    }

    public JComponent challengesPanel() {
      challengeCRUD = new SimpleCRUD_v2<>(concepts, G22Challenge.class);
      setupScriptCRUD(challengeCRUD);
      challengeCRUD.addCountToEnclosingTab(true);
      challengeCRUD.entityName = () -> "Challenge";
      recognizerCRUD = new SimpleCRUD_v2<>(concepts, G22RecognizerScript.class);
      recognizerCRUD.entityName = () -> "Recognizer";
      setupScriptCRUD(recognizerCRUD);
      var challengeCRUDVis = challengeCRUD.visualize();
      var recognizerCRUDVis = recognizerCRUD.visualize();
      scpChallengePanel = singleComponentPanel();
      scpChallengeCode = singleComponentPanel();
      challengeCRUD.onSelectionChangedAndNow(r_dm_q(() -> makeChallengePanel()));
      return jhsplit(withTopRightAndBottomMargin(jCenteredRaisedSection("Challenges", withSideAndBottomMargin(jvsplit(jvsplit(withBottomMargin(challengeCRUDVis), scpChallengeCode), jCenteredRaisedSection("Recognizers", recognizerCRUDVis))))), withSideMargins(scpChallengePanel));
    }

    public void makeChallengePanel() {
      var challenge = challengeCRUD.selected();
      if (challenge == null) {
        scpChallengePanel.clear();
        scpChallengeCode.set(jcenteredlabel("Please select a challenge above to start"));
        return;
      }
      scpChallengeCode.set(jCenteredSection("Code for challenge", liveValueRSyntaxTextArea_bothWays(conceptFieldLiveValue("code", challenge))));
      var panel = new G22ChallengePanel(challenge);
      panel.g22utils(g22utils);
      panel.init();
      panel.recognizerIDE.lvScript(dm_liveValue("recognizerScript"));
      scpChallengePanel.set(withTopAndBottomMargin(12, 6, panel.visualize()));
    }

    public Gazelle22_ImageToRegions imageToRegions(BufferedImage inputImage, SnPSettings snpSettings) {
      return new Gazelle22_ImageToRegions(functionTimings, inputImage, snpSettings);
    }

    public JComponent databasesPanel() {
      return new G22DatabasesPanel(g22utils, concepts).visualize();
    }
  }

  static public boolean _moduleClass_GazelleScreenCam = true;

  static public class Label extends ConceptWithGlobalID {

    public String name;

    public String toString() {
      return name;
    }
  }

  static public class GalleryImage extends Concept {

    public File path;

    public String toString() {
      return fileName(path);
    }

    public boolean imageExists() {
      return fileExists(path);
    }
  }

  static public class SavedRegion extends Concept {

    static final public String _fieldOrder = "image snpSettings regionIndex bitMatrix";

    public Ref image = new Ref();

    public SnPSettings snpSettings;

    public int regionIndex;

    public ScanlineBitMatrix bitMatrix;
  }

  static public class Example extends Concept {

    static final public String _fieldOrder = "label item confidence";

    public Ref<Label> label = new Ref();

    public Ref item = new Ref();

    public double confidence = 1;
  }

  static public class IfThenTheory extends Concept {

    public Ref if_ = new Ref();

    public Ref then = new Ref();
  }

  abstract static public class WatchTarget {

    abstract public void configureScreenCamStream(ScreenCamStream stream);
  }

  static public class WatchScreen extends WatchTarget implements IFieldsToList {

    public int screenNr;

    public WatchScreen() {
    }

    public WatchScreen(int screenNr) {
      this.screenNr = screenNr;
    }

    public boolean equals(Object o) {
      if (!(o instanceof WatchScreen))
        return false;
      WatchScreen __15 = (WatchScreen) o;
      return screenNr == __15.screenNr;
    }

    public int hashCode() {
      int h = -1787428357;
      h = boostHashCombine(h, _hashCode(screenNr));
      return h;
    }

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

    public String toString() {
      return "Screen " + screenNr;
    }

    public void configureScreenCamStream(ScreenCamStream stream) {
      stream.useScreen(screenNr - 1);
    }
  }

  static public class WatchMouse extends WatchTarget implements IFieldsToList {

    static final public String _fieldOrder = "width height";

    public int width;

    public int height;

    public WatchMouse(int width, int height) {
      this.height = height;
      this.width = width;
    }

    public boolean equals(Object o) {
      if (!(o instanceof WatchMouse))
        return false;
      WatchMouse __16 = (WatchMouse) o;
      return width == __16.width && height == __16.height;
    }

    public int hashCode() {
      int h = 1876823350;
      h = boostHashCombine(h, _hashCode(width));
      h = boostHashCombine(h, _hashCode(height));
      return h;
    }

    public Object[] _fieldsToList() {
      return new Object[] { width, height };
    }

    public WatchMouse() {
      height = 256;
      width = iround(height * 16.0 / 9);
    }

    public String toString() {
      return "Mouse";
    }

    public void configureScreenCamStream(ScreenCamStream stream) {
      stream.area(mouseArea(width, height));
    }
  }

  static public class WatchScreenWithMouse extends WatchTarget implements IFieldsToList {

    public WatchScreenWithMouse() {
    }

    public boolean equals(Object o) {
      return o instanceof WatchScreenWithMouse;
    }

    public int hashCode() {
      int h = -1449766972;
      return h;
    }

    public Object[] _fieldsToList() {
      return null;
    }

    public String toString() {
      return "Screen w/mouse";
    }

    public void configureScreenCamStream(ScreenCamStream stream) {
      stream.useScreen(screenNrContaining(mouseLocationPt()));
    }
  }

  static public Rect leftScreenBounds() {
    return first(allScreenBounds());
  }

  static public Rect rightScreenBounds() {
    return second(allScreenBounds());
  }

  static public Rect mergeRects(List<Rect> l) {
    Rect r = first(l);
    for (int i = 1; i < l(l); i++) r = rectUnion(r, l.get(i));
    return r;
  }

  static public Rect mergeRects(Rect a, Rect b) {
    return rectUnion(a, b);
  }

  static public double g22_squareness(Rect r) {
    return doubleRatio(min(r.w, r.h), max(r.w, r.h));
  }

  static public double g22_regionFilledness(IImageRegion region) {
    return doubleRatio(region.numberOfPixels(), area(region.bounds()));
  }

  static public BigInteger mul(BigInteger a, BigInteger b) {
    return a.multiply(b);
  }

  static public BigInteger mul(BigInteger a, long b) {
    return a.multiply(bigint(b));
  }

  static public int mul(int a, int b) {
    return a * b;
  }

  static public BufferedImage newImage(int w, int h) {
    return whiteImage(w, h);
  }

  static public BufferedImage newImage(int w, int h, Color color) {
    return bufferedImage(w, h, color);
  }

  static public BufferedImage newImage(int size) {
    return whiteImage(size);
  }

  static public Rect randomRect(Rect outer) {
    var w = random_incl(outer.w);
    var h = random_incl(outer.h);
    return randomRect(w, h, outer);
  }

  static public Rect randomRect(int w, int h, Rect outer) {
    return translateRect(outer.x, outer.y, randomRect(outer.w, outer.h, 0, w, h));
  }

  static public Rect randomRect(Rect outer, int w, int h) {
    return randomRect(w, h, outer);
  }

  static public Rect randomRect(int w, int h, int rw, int rh) {
    return randomRect(w, h, 0, rw, rh);
  }

  static public Rect randomRect(int w, int h, int border, int rw, int rh) {
    if (rw > w - border * 2 || rh > h - border * 2)
      return null;
    int ww = random(border, w - border - rw);
    int hh = random(border, h - border - rh);
    return new Rect(ww, hh, rw, rh);
  }

  static public Rect randomRect(int w, int h) {
    int rw = random(w);
    int rh = random(h);
    return randomRect(w, h, 0, rw, rh);
  }

  static public Rect randomRect(RGBImage img, int rw, int rh) {
    return randomRect(img.w(), img.h(), 0, rw, rh);
  }

  static public Rect randomRect(RGBImage img) {
    return randomRect(img.w(), img.h());
  }

  static public Rect randomRect() {
    return randomRect(currentImage().getWidth(), currentImage().getHeight());
  }

  static public Rect randomRect(BufferedImage img, int rw, int rh) {
    return randomRect(img.getWidth(), img.getHeight(), 0, rw, rh);
  }

  static public boolean lessThan(int a, int b) {
    return a < b;
  }

  static public boolean lessThan(double a, double b) {
    return a < b;
  }

  static public <Img extends WidthAndHeight> IImageRegion<Img> g22_darkestRegion(IImageRegions<Img> regions) {
    return regions == null ? null : lowest(regions.regions(), r -> r.brightness());
  }

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

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

  static public JCheckBox dm_checkBox(String field) {
    return dm_fieldCheckBox(field);
  }

  static public JCheckBox dm_checkBox(String text, String field) {
    return dm_fieldCheckBox(text, field);
  }

  static public ReliableSingleThread dm_rst(Runnable r) {
    return dm_rst(dm_current_mandatory(), r);
  }

  static public ReliableSingleThread dm_rst(DynModule mod, Runnable r) {
    return dm_rst(mod, new ReliableSingleThread(r));
  }

  static public ReliableSingleThread dm_rst(DynModule mod, ReliableSingleThread rst) {
    rst.enter = dm_rEnter(mod);
    return rst;
  }

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

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

  static public void dm_onFieldChange(String field, Runnable onChange) {
    dm_watchField(field, onChange);
  }

  static public void dm_onFieldChange(Collection<String> fields, Runnable onChange) {
    dm_watchFields(fields, onChange);
  }

  static public void assertSame(Object a, Object b) {
    assertSame("", a, b);
  }

  static public void assertSame(String msg, Object a, Object b) {
    if (a != b)
      throw fail(joinNemptiesWithColon(msg, a + " != " + b + " (" + identityHash(a) + "/" + identityHash(b) + ")"));
  }

  static public void indexConceptField(Class<? extends Concept> c, String field) {
    indexConceptField(db_mainConcepts(), c, field);
  }

  static public void indexConceptField(Concepts concepts, Class<? extends Concept> c, String field) {
    if (!isConceptFieldIndexed(concepts, c, field))
      new ConceptFieldIndex(concepts, c, field);
  }

  static public void onConceptChanges(Runnable r) {
    onConceptsChange(r);
  }

  static public void onConceptChanges(Concepts cc, Runnable r) {
    onConceptsChange(cc, r);
  }

  static public void updateEnclosingTabTitleWithCount(JComponent c, int n) {
    Pair<JTabbedPane, Integer> p = enclosingTab(c);
    if (p == null)
      return;
    setTabTitle(p.a, p.b, appendBracketedCount(dropTrailingBracketedCount(getTabTitle(p.a, p.b)), n));
  }

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

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

  static public int countConcepts() {
    return db_mainConcepts().countConcepts();
  }

  static public int countConcepts(String className) {
    return db_mainConcepts().countConcepts(className);
  }

  static public <A extends Concept> int countConcepts(Concepts concepts, String className) {
    return concepts.countConcepts(className);
  }

  static public int countConcepts(Concepts concepts) {
    return concepts.countConcepts();
  }

  static public void dm_watchFieldAndNow(String field, Runnable onChange) {
    dm_watchField(field, onChange);
    dm_q(onChange);
  }

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

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

  static public Object getMetaSrc(Object o) {
    return metaGet("src", o);
  }

  static public void g22_runPostAnalysisLeftArrowScript(Gazelle22_ImageToRegions itr, GazelleV_LeftArrowScript.Script script) {
    if (script == null)
      return;
    var fScore = script.getFunction("score");
    if (fScore != null) {
      List<IImageRegion<BWImage>> regions = itr.regions.regions();
      int n = l(regions);
      Map<IImageRegion<BWImage>, Double> scores = new HashMap();
      for (var region : regions) scores.put(region, toDouble(fScore.call(null, region)));
      itr.scoredRegions = mapSortedByValue(scores);
    }
  }

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

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

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

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

  static public String nRegions(long n) {
    return n2(n, "region");
  }

  static public String nRegions(Collection l) {
    return nRegions(l(l));
  }

  static public String nRegions(Map map) {
    return nRegions(l(map));
  }

  static public void g22_renderPosterizedHighlightedImage(ImageSurface isPosterized, Gazelle22_ImageToRegions itr, boolean showRegionsAsOutline) {
    if (isPosterized == null)
      return;
    var mouse = mouseLocationPt();
    if (!isScreenCoordinateInWindow(mouse, isPosterized)) {
      var mouse2 = itr.coordinatesFromScreen(mouse);
      mouse = mouse2;
    } else
      mouse = isPosterized.mousePosition;
    var pixels = itr.posterized.getRGBPixels();
    g22_highlightRegion(pixels, isPosterized, itr, mouse, showRegionsAsOutline);
    if (itr.scoredRegions != null)
      for (Map.Entry<? extends IImageRegion, ? extends Double> __0 : _entrySet(itr.scoredRegions)) {
        IImageRegion region = __0.getKey();
        double score = __0.getValue();
        if (score >= .5) {
          int color = colorToIntOpaque(blendColors(lightBlue(), Color.blue, (score - .5) * 2));
          g22_highlightRegion(pixels, isPosterized, itr, region.indexInCreator(), color, false);
        }
      }
    isPosterized.setImage(bufferedImage(pixels, itr.posterized));
  }

  static public void ownResource(AutoCloseable c) {
    _registerAutoCloseable(c);
  }

  static public Timestamp tsNowPlusMS(long ms) {
    return tsNow().plus(msToSeconds(ms));
  }

  static public Timestamp tsNowPlusMS(double ms) {
    return tsNow().plus(msToSeconds(ms));
  }

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

  static public List<File> allImageFiles(File dir) {
    return filter(__43 -> isImageFile(__43), findAllFiles_noDirs(dir));
  }

  static public File picturesDir() {
    return imagesDir();
  }

  static public File picturesDir(String sub) {
    return newFile(picturesDir(), sub);
  }

  static public boolean isImageFile(File f) {
    return isImageFileName(fileName(f)) && isFile(f);
  }

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

  static public List map(Object f, Iterable l) {
    List x = emptyList(l);
    if (l != null)
      for (Object o : l) {
        ping();
        x.add(callF(f, o));
      }
    return x;
  }

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

  static public <A, B> List<B> map(F1<A, B> f, Iterable<A> l) {
    List x = emptyList(l);
    if (l != null)
      for (A o : l) {
        ping();
        x.add(callF(f, o));
      }
    return x;
  }

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

  static public <A, B> List<B> map(Iterable<A> l, IF1<A, B> f) {
    List x = emptyList(l);
    if (l != null)
      for (A o : l) {
        ping();
        x.add(f.get(o));
      }
    return x;
  }

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

  static public <A, B> List<B> map(A[] l, IF1<A, B> f) {
    List x = emptyList(l);
    if (l != null)
      for (A o : l) {
        ping();
        x.add(f.get(o));
      }
    return x;
  }

  static public List map(Object f, Object[] l) {
    return map(f, asList(l));
  }

  static public List map(Object[] l, Object f) {
    return map(f, l);
  }

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

  static public List map(Map map, Object f) {
    List x = new ArrayList();
    if (map != null)
      for (Object _e : map.entrySet()) {
        ping();
        Map.Entry e = (Map.Entry) _e;
        x.add(callF(f, e.getKey(), e.getValue()));
      }
    return x;
  }

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

  static public <A, B> List<A> map(IF1<A, B> f, A data1, A... moreData) {
    List x = emptyList(l(moreData) + 1);
    x.add(f.get(data1));
    if (moreData != null)
      for (A o : moreData) {
        ping();
        x.add(f.get(o));
      }
    return x;
  }

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

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

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

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

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

  static public LinkedHashMap litorderedmap(Object... x) {
    LinkedHashMap map = new LinkedHashMap();
    litmap_impl(map, x);
    return map;
  }

  static public String n2(long l) {
    return formatWithThousands(l);
  }

  static public String n2(AtomicLong l) {
    return n2(l.get());
  }

  static public String n2(Collection l) {
    return n2(l(l));
  }

  static public String n2(Map map) {
    return n2(l(map));
  }

  static public String n2(double l, String singular) {
    return empty(singular) ? str(l) : n2(l, singular, singular + "s");
  }

  static public String n2(double l, String singular, String plural) {
    if (fraction(l) == 0)
      return n2((long) l, singular, plural);
    else
      return l + " " + plural;
  }

  static public String n2(long l, String singular, String plural) {
    return n_fancy2(l, singular, plural);
  }

  static public String n2(long l, String singular) {
    return empty(singular) ? n2(l) : n_fancy2(l, singular, singular + "s");
  }

  static public String n2(Collection l, String singular) {
    return n2(l(l), singular);
  }

  static public String n2(Collection l, String singular, String plural) {
    return n_fancy2(l, singular, plural);
  }

  static public String n2(Map m, String singular, String plural) {
    return n_fancy2(m, singular, plural);
  }

  static public String n2(Map m, String singular) {
    return n2(l(m), singular);
  }

  static public String n2(long[] a, String singular) {
    return n2(l(a), singular);
  }

  static public String n2(Object[] a, String singular) {
    return n2(l(a), singular);
  }

  static public String n2(Object[] a, String singular, String plural) {
    return n_fancy2(a, singular, plural);
  }

  static public String n2(MultiSet ms, String singular, String plural) {
    return n_fancy2(ms, singular, plural);
  }

  static public String fileName(File f) {
    return f == null ? null : f.getName();
  }

  static public String dirPath(File f) {
    return f == null ? null : f.getParent();
  }

  static public JScrollPane borderlessScrollPane(JScrollPane sp) {
    return setBorder(null, withoutViewportBorder(sp));
  }

  static public JScrollPane jHigherScrollPane(final JComponent c) {
    return swing(new F0<JScrollPane>() {

      public JScrollPane get() {
        try {
          return new JScrollPane(c) {

            public Dimension getPreferredSize() {
              Component view = getViewport().getView();
              if (view == null)
                return super.getPreferredSize();
              int pref_width = view.getPreferredSize().width;
              setHorizontalScrollBarPolicy(JScrollPane.HORIZONTAL_SCROLLBAR_ALWAYS);
              Dimension dim = new Dimension(pref_width, super.getPreferredSize().height + getHorizontalScrollBar().getSize().height);
              setHorizontalScrollBarPolicy(JScrollPane.HORIZONTAL_SCROLLBAR_AS_NEEDED);
              return dim;
            }
          };
        } catch (Exception __e) {
          throw rethrow(__e);
        }
      }

      public String toString() {
        return "ret new JScrollPane(c) {\r\n    public Dimension getPreferredSize() {\r\n      Co...";
      }
    });
  }

  static public JPanel jfullcenter(Component c) {
    return jFullCenter(c);
  }

  static public JPanel vstack(Object... parts) {
    return vstack2(parts);
  }

  static public JPanel vstack(List parts) {
    return vstack(toObjectArray(parts));
  }

  static public JPanel hstack(Object... parts) {
    JPanel panel = new JPanel(new GridBagLayout());
    GridBagConstraints gbc = new GridBagConstraints();
    gbc.weighty = 1;
    gbc.fill = GridBagConstraints.VERTICAL;
    gbc.gridheight = GridBagConstraints.REMAINDER;
    smartAddWithLayout(panel, gbc, parts);
    gbc.weightx = 1;
    panel.add(jrigid(), gbc);
    return panel;
  }

  static public JCheckBox dm_rcheckBox(String field) {
    return dm_fieldCheckBox(field);
  }

  static public JCheckBox dm_rcheckBox(String field, String text) {
    return dm_fieldCheckBox(text, field);
  }

  static public JComponent withLabelToTheRight(JComponent component, String label) {
    return centerAndEast(component, jlabel(" " + label));
  }

  static public JComponent withLabelToTheRight(String label, JComponent component) {
    return withLabelToTheRight(component, label);
  }

  static public JSpinner dm_spinner(String field, int min, int max) {
    return liveValueSpinner(dm_fieldLiveValue(field), min, max);
  }

  static public JSpinner dm_powersOfTwoSpinner(String field, int max) {
    SimpleLiveValue<Integer> lv = dm_fieldLiveValue(field);
    return bindLiveValueToSpinner(lv, jPowersOfTwoSpinner(max, lv.get()));
  }

  static public Component verticalStrut(int height) {
    return Box.createVerticalStrut(height);
  }

  static public JPanel withSideMargins(Component c) {
    return withLeftAndRightMargin(c);
  }

  static public JPanel withSideMargins(int w, Component c) {
    return withLeftAndRightMargin(w, c);
  }

  static public JPanel withSideMargins(int w1, int w2, Component c) {
    return withLeftAndRightMargin(w1, w2, c);
  }

  static public <A extends JComponent> A dm_transientCalculatedToolTip(IF0<Object> calc, A component) {
    return toolTipFromLiveValue(dm_transientCalculatedLiveValue(Object.class, calc), component);
  }

  static public <A extends JLabel> A rightAlignLabel(final A a) {
    return setHorizontalAlignment(JLabel.RIGHT, a);
  }

  static public JLabel dm_transientCalculatedLabel(IF0<Object> calc) {
    return jLiveValueLabel(dm_transientCalculatedLiveValue(Object.class, calc));
  }

  static public JTabbedPane scrollingTabs(JTabbedPane pane) {
    if (pane != null) {
      swing(() -> {
        pane.setTabLayoutPolicy(JTabbedPane.SCROLL_TAB_LAYOUT);
      });
    }
    return pane;
  }

  static public JTabbedPane jTopOrLeftTabs(boolean horizontal, Object... x) {
    return jLeftOrTopTabs(horizontal, x);
  }

  static public JTabbedPane jTopOrLeftTabs(boolean horizontal, Collection c) {
    return jLeftOrTopTabs(horizontal, c);
  }

  static public SingleComponentPanel jOnDemand(IF0<JComponent> makeComponent) {
    SingleComponentPanel scp = singleComponentPanel();
    bindToComponent(scp, () -> {
      try {
        scp.setComponent(makeComponent == null ? null : makeComponent.get());
      } catch (Throwable e) {
        printStackTrace(e);
        scp.setComponent(jscroll(jFastLogView_noWrap(renderStackTrace(e))));
      }
    }, null);
    return scp;
  }

  static public int withTopAndBottomMargin_defaultWidth = 6;

  static public JPanel withTopAndBottomMargin(Component c) {
    return withTopAndBottomMargin(withTopAndBottomMargin_defaultWidth, withTopAndBottomMargin_defaultWidth, c);
  }

  static public JPanel withTopAndBottomMargin(int topMargin, int bottomMargin, Component c) {
    return swing(() -> {
      JPanel p = new JPanel(new BorderLayout());
      int w = withTopAndBottomMargin_defaultWidth;
      p.setBorder(BorderFactory.createEmptyBorder(topMargin, 0, bottomMargin, 0));
      p.add(c);
      return p;
    });
  }

  static public JPanel withRightAlignedButtons(JComponent center, Object... params) {
    return centerAndSouth(center, withMargin(jRightAlignedButtons(params)));
  }

  static public JPanel withRightAlignedButtons(Swingable center, Object... params) {
    return withRightAlignedButtons(wrap(center), params);
  }

  static public void addTabs(JTabbedPane tabs, Object... x) {
    if (tabs == null)
      return;
    x = flattenToArray(x);
    for (int i = 0; i < l(x); i++) {
      Object o = x[i];
      if (isComponentOrSwingable(o))
        addTab(tabs, "Tab " + (tabCount(tabs) + 1), wrap(o));
      else {
        String toolTip = "";
        if (o instanceof WithToolTip) {
          toolTip = ((WithToolTip) o).toolTip();
          o = ((WithToolTip) o).get();
        }
        String name = str(or(o, "Tab " + tabCount(tabs) + 1));
        Component c;
        if (isComponentOrSwingable(get(x, i + 1)))
          c = wrap(get(x, ++i));
        else
          c = new JPanel();
        addTabWithToolTip(tabs, name, toolTip, wrap(c));
      }
    }
  }

  static public List<String> tabNames(JTabbedPane tabs) {
    return tabs == null ? null : swing(() -> countIteratorToList(tabs.getTabCount(), i -> tabs.getTitleAt(i)));
  }

  static public String dropTrailingBracketedCount(String s) {
    return replaceAll(s, "\\s?\\([0-9,]+\\)$", "");
  }

  static public int indexOfTabNameWithoutTrailingCount(JTabbedPane tabs, String name) {
    if (tabs == null)
      return 1;
    return swing(() -> {
      var _name_1 = dropTrailingBracketedCount(name);
      int n = tabs.getTabCount();
      for (int i = 0; i < n; i++) if (eqic(_name_1, dropTrailingBracketedCount(tabs.getTitleAt(i))))
        return i;
      return -1;
    });
  }

  static public JLabel jcenteredlabel(String text) {
    return jcenteredLabel(text);
  }

  static public JLabel jcenteredlabel() {
    return jcenteredLabel();
  }

  static public void selectTab(final JTabbedPane tabs, final int idx) {
    if (tabs != null) {
      swing(() -> {
        tabs.setSelectedIndex(idx);
      });
    }
  }

  static public <A extends JComponent> A setToolTip(A c, Object toolTip) {
    return setToolTipText(c, toolTip);
  }

  static public <A extends JComponent> A setToolTip(Object toolTip, A c) {
    return setToolTipText(c, toolTip);
  }

  static public void setToolTip(TrayIcon trayIcon, String toolTip) {
    setTrayIconToolTip(trayIcon, toolTip);
  }

  static public void tabComponentClickFixer(JComponent c) {
    onMouseDown(c, e -> {
      JTabbedPane tabs = parentOfType(c, JTabbedPane.class);
      if (tabs == null)
        return;
      var tabComponents = tabComponents(tabs);
      for (int i = 0; i < l(tabComponents); i++) if (isGrandChildOf(c, tabComponents.get(i))) {
        {
          selectTab(tabs, i);
          return;
        }
      }
    });
  }

  static public int hstackWithSpacing_spacing = 10;

  static public JPanel hstackWithSpacing(Object... parts) {
    parts = flattenArray2(parts);
    int spacing = hstackWithSpacing_spacing;
    int i = 0;
    if (first(parts) instanceof Integer) {
      spacing = toInt(first(parts));
      ++i;
    }
    JPanel panel = new JPanel(new GridBagLayout());
    GridBagConstraints gbc = new GridBagConstraints();
    gbc.weighty = 1;
    gbc.fill = GridBagConstraints.VERTICAL;
    gbc.gridheight = GridBagConstraints.REMAINDER;
    for (; i < l(parts); i++) {
      if (i != 0)
        panel.add(javax.swing.Box.createRigidArea(new Dimension(spacing, 0)), gbc);
      panel.add(wrapForSmartAdd(parts[i]), gbc);
    }
    gbc.weightx = 1;
    panel.add(jrigid(), gbc);
    return panel;
  }

  static public boolean replaceTabTitleComponent(JTabbedPane tabs, String name, Component c) {
    if (tabs == null)
      return false;
    return swing(new F0<Boolean>() {

      public Boolean get() {
        try {
          int idx = tabs.indexOfTab(name);
          if (idx < 0)
            return false;
          tabs.setTabComponentAt(idx, c);
          return true;
        } catch (Exception __e) {
          throw rethrow(__e);
        }
      }

      public String toString() {
        return "int idx = tabs.indexOfTab(name);\r\n    if (idx < 0) false;\r\n    tabs.setTabCom...";
      }
    });
  }

  static public void persistSelectedTabAsLiveValue(JTabbedPane tabs, SimpleLiveValue<String> lv) {
    String value = lv.get();
    if (value != null) {
      int idx = indexOfTabName(tabs, value);
      if (idx >= 0)
        selectTab(tabs, idx);
    }
    onChangeAndNow(tabs, () -> {
      String name = getTabTitle(tabs, selectedTabIndex(tabs));
      lv.set(name);
    });
  }

  static public <A extends JComponent> A focusOnFirstShow(A a) {
    return focusOnShow(a);
  }

  static public String f2s(File f) {
    return f == null ? null : f.getAbsolutePath();
  }

  static public String f2s(String s) {
    return f2s(newFile(s));
  }

  static public String f2s(java.nio.file.Path p) {
    return p == null ? null : f2s(p.toFile());
  }

  static public JLabel jSimpleLabel() {
    return jSimpleLabel("");
  }

  static public JLabel jSimpleLabel(String text) {
    return swing(() -> new JLabel(text));
  }

  static public String conceptsDirName() {
    return conceptsDirName(db_mainConcepts());
  }

  static public String conceptsDirName(Concepts cc) {
    return fileName(cc.conceptsDir());
  }

  static public <A extends JComponent> A componentPopupMenuItems(A c, final Object... params) {
    componentPopupMenu(c, new VF1<JPopupMenu>() {

      public void get(JPopupMenu menu) {
        try {
          addMenuItems(menu, params);
        } catch (Exception __e) {
          throw rethrow(__e);
        }
      }

      public String toString() {
        return "addMenuItems(menu, params)";
      }
    });
    return c;
  }

  static public JPanel withSideAndTopMargin(Component c) {
    return withSideAndTopMargin(defaultMargin(), c);
  }

  static public JPanel withSideAndTopMargin(int w, Component c) {
    return swing(() -> {
      JPanel p = marginPanel();
      p.setBorder(BorderFactory.createEmptyBorder(w, w, 0, w));
      p.add(c);
      return p;
    });
  }

  static public JPanel centerAndSouthOrEast(boolean horizontal, Component c, Component s) {
    return horizontal ? centerAndEast(c, s) : centerAndSouth(c, s);
  }

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

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

  static public String getText(final AbstractButton c) {
    return c == null ? "" : (String) swingAndWait(new F0<Object>() {

      public Object get() {
        try {
          return c.getText();
        } catch (Exception __e) {
          throw rethrow(__e);
        }
      }

      public String toString() {
        return "return c.getText();";
      }
    });
  }

  static public String getText(final JTextComponent c) {
    return c == null ? "" : (String) swingAndWait(new F0<Object>() {

      public Object get() {
        try {
          return c.getText();
        } catch (Exception __e) {
          throw rethrow(__e);
        }
      }

      public String toString() {
        return "return c.getText();";
      }
    });
  }

  static public String getText(final JLabel l) {
    return l == null ? "" : (String) swingAndWait(new F0<Object>() {

      public Object get() {
        try {
          return l.getText();
        } catch (Exception __e) {
          throw rethrow(__e);
        }
      }

      public String toString() {
        return "return l.getText();";
      }
    });
  }

  static public String getText(final JComboBox cb) {
    if (cb == null)
      return null;
    if (isEditableComboBox(cb))
      return unnull((String) cb.getEditor().getItem());
    else
      return str(cb.getSelectedItem());
  }

  static public JScrollPane jscroll_centered_borderless(Component c) {
    return borderlessScrollPane(jscroll_centered(c));
  }

  static public String nFrames(long n) {
    return n2(n, "frame");
  }

  static public String nFrames(Collection l) {
    return nFrames(l(l));
  }

  static public String nFrames(Map map) {
    return nFrames(l(map));
  }

  static public String lines(Iterable lines) {
    return fromLines(lines);
  }

  static public String lines(Object[] lines) {
    return fromLines(asList(lines));
  }

  static public List<String> lines(String s) {
    return toLines(s);
  }

  static public <A> String lines(Iterable<A> l, IF1<A, String> f) {
    return mapToLines(l, f);
  }

  static public List<String> ciSorted(Collection<String> c) {
    return sortedIgnoreCase(c);
  }

  static public double nsToMicroseconds(double ns) {
    return nanosToMicroseconds(ns);
  }

  static public String microSymbol() {
    return "\u00B5";
  }

  static public boolean isShowing(Component c) {
    return isComponentShowing(c);
  }

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

  static public JCheckBoxMenuItem jCheckBoxMenuItem_dyn(String text, IF0<Boolean> checked, Object r) {
    JCheckBoxMenuItem mi = jCheckBoxMenuItem(text, false, r);
    if (checked != null)
      bindToComponent(mi, new Runnable() {

        public void run() {
          try {
            boolean b = isTrue(checked.get());
            setChecked(mi, b);
          } catch (Exception __e) {
            throw rethrow(__e);
          }
        }

        public String toString() {
          return "boolean b = isTrue(checked!);\r\n    ifdef jCheckBoxMenuItem_dyn_debug\r\n      p...";
        }
      }, new Runnable() {

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

        public String toString() {
          return "ifdef jCheckBoxMenuItem_dyn_debug\r\n      print(\"jCheckBoxMenuItem_dyn: hiding...";
        }
      });
    return mi;
  }

  static public JCheckBoxMenuItem jCheckBoxMenuItem_dyn(String text, IF0<Boolean> checked, IVF1<Boolean> r) {
    return jCheckBoxMenuItem_dyn(text, checked, (Object) r);
  }

  static public JButton jimageButtonScaledToWidth(int w, String imageID, Runnable action) {
    return jimageButtonScaledToWidth(w, imageID, "", action);
  }

  static public JButton jimageButtonScaledToWidth(int w, String imageID, String toolTip, Runnable action) {
    return jimageButton(scaleImageToWidth(w, imageID), toolTip, action);
  }

  static public JComboBox jComboBox(final String... items) {
    return jcombobox(items);
  }

  static public JComboBox jComboBox(Collection<String> items) {
    return jcombobox(items);
  }

  static public JComboBox jComboBox(Collection<String> items, String selectedItem) {
    return jcombobox(items, selectedItem);
  }

  static public <A> JComboBox<A> selectItem(A item, JComboBox<A> cb) {
    if (cb != null) {
      swing(() -> {
        cb.setSelectedItem(item);
      });
    }
    return cb;
  }

  static public <A> JComboBox<A> selectItem(JComboBox<A> cb, A item) {
    return selectItem(item, cb);
  }

  static public <A> JList<A> selectItem(JList<A> list, A item) {
    {
      swing(() -> {
        selectRow(list, jlist_indexOf(list, item));
      });
    }
    return list;
  }

  static public int screenCount() {
    return l(GraphicsEnvironment.getLocalGraphicsEnvironment().getScreenDevices());
  }

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

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

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

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

  static public <A> void setComboBoxItems(JComboBox<A> cb, Collection<A> items) {
    if (cb != null) {
      swing(() -> {
        cb.setModel(new DefaultComboBoxModel(new Vector(items)));
      });
    }
  }

  static public List flattenToList(Object... l) {
    Flattener f = new Flattener();
    f.add(l);
    return f.toList();
  }

  static public List<Integer> countIteratorAsList_incl(int b) {
    return countIteratorAsList_incl(0, b);
  }

  static public List<Integer> countIteratorAsList_incl(int a, int b) {
    return countIteratorToList_inclusive(a, b);
  }

  static public <A> List<A> countIteratorAsList_incl(int b, IF1<Integer, A> f) {
    return countIteratorAsList_incl(0, b, f);
  }

  static public <A> List<A> countIteratorAsList_incl(int a, int b, IF1<Integer, A> f) {
    return countIteratorToList_inclusive(a, b, f);
  }

  static public List<Integer> countIteratorAsList_incl(int a, int b, int step) {
    return countIteratorToList_inclusive(a, b, step);
  }

  static public <A> List<A> countIteratorAsList_incl(double a, double b, double step, IF1<Double, A> f) {
    return countIteratorToList_inclusive(a, b, step, f);
  }

  static public <A> List<Double> countIteratorAsList_incl(double a, double b, double step) {
    return countIteratorToList_inclusive(a, b, step);
  }

  static public <A> List<A> countIteratorAsList_incl(IF1<Double, A> f, double a, double b, double step) {
    return countIteratorToList_inclusive(f, a, b, step);
  }

  static public <A> List<A> countIteratorAsList_incl(IF1<Integer, A> f, int a, int b) {
    return countIteratorAsList_incl(f, a, b, 1);
  }

  static public <A> List<A> countIteratorAsList_incl(IF1<Integer, A> f, int a, int b, int step) {
    return countIteratorToList_inclusive(f, a, b, step);
  }

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

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

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

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

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

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

  static public JSpinner jspinner(int value) {
    return jSpinner(value);
  }

  static public JSpinner jspinner(int value, int min, int max) {
    return jSpinner(value, min, max);
  }

  static public int intFromSpinner(JSpinner s) {
    return toInt(s.getValue());
  }

  static public <A> JSpinner jPowersOfTwoSpinner(int max, int defaultValue) {
    return jPowersOfTwoSpinner(1, max, defaultValue);
  }

  static public <A> JSpinner jPowersOfTwoSpinner(int min, int max, int defaultValue) {
    var powers = powersOfTwoUpTo(max);
    if (min > 1)
      powers = filter(powers, x -> x >= min);
    return rightAlignSpinner(jListSpinner(powers, defaultValue));
  }

  static public JPanel jRaisedSection(Component c) {
    return jRaisedSection("", c);
  }

  static public JPanel jRaisedSection(final String title, final Component c) {
    return swing(new F0<JPanel>() {

      public JPanel get() {
        try {
          Border border = BorderFactory.createBevelBorder(BevelBorder.RAISED);
          border = BorderFactory.createTitledBorder(border, title);
          JPanel panel = new SingleComponentPanel(c);
          panel.setBorder(border);
          return panel;
        } catch (Exception __e) {
          throw rethrow(__e);
        }
      }

      public String toString() {
        return "Border border = BorderFactory.createBevelBorder(BevelBorder.RAISED);\r\n    bor...";
      }
    });
  }

  static public JPanel jRaisedSection(String title) {
    return jRaisedSection(title, new JPanel());
  }

  static public String gazelle22_imagesSubDirName() {
    return "Gazelle";
  }

  static public File saveImageWithCounter(File dir, String baseName, BufferedImage img) {
    if (img == null || dir == null)
      return null;
    if (!isImageFileName(baseName))
      baseName += ".png";
    File f = makeFileNameUnique_beforeExtension_startWith1_noDot(newFile(dir, baseName));
    saveImage(f, img);
    infoBox("Saved image " + appendBracketed(img.getWidth(null) + "*" + img.getHeight(null)) + ": " + fileInfo(f));
    return f;
  }

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

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

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

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

  static public int cmpAlphanumIC(String a, String b) {
    return cmpAlphaNum(a, b);
  }

  static public void onChangeAndNow(JComponent c, Object r) {
    onUpdateAndNow(c, r);
  }

  static public void onChangeAndNow(List<? extends JComponent> l, Object r) {
    onUpdateAndNow(l, r);
  }

  static public <A> JComboBox<A> onChangeAndNow(JComboBox<A> cb, IVF1<A> f) {
    onChange(cb, f);
    {
      if (f != null)
        f.get(getSelectedItem_typed(cb));
    }
    return cb;
  }

  static public <A extends JTabbedPane> A onChangeAndNow(A tabs, Runnable r) {
    if (r != null) {
      onChange(tabs, r);
      r.run();
    }
    return tabs;
  }

  static public Runnable r_dm_q(final Runnable r) {
    DynModule mod = dm_current_mandatory();
    return r_dm_q(mod, r);
  }

  static public Runnable r_dm_q(DynModule mod, Runnable r) {
    return new Runnable() {

      public void run() {
        try {
          dm_q(mod, r);
        } catch (Exception __e) {
          throw rethrow(__e);
        }
      }

      public String toString() {
        return "dm_q(mod, r)";
      }
    };
  }

  static public void imageSurfaceOnLeftMouseDown(ImageSurface is, IVF1<Pt> action) {
    if (is == null || action == null)
      return;
    {
      swing(() -> {
        MouseAdapter ma = new MouseAdapter() {

          public void mousePressed(MouseEvent e) {
            if (e.getButton() == 1)
              pcallF(action, is.pointFromEvent(e));
          }
        };
        is.addMouseListener(ma);
      });
    }
  }

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

  static public <A extends Concept> A uniq_returnIfNew(Concepts cc, Class<A> c, Object... params) {
    Pair<A, Boolean> p = uniq2(cc, c, params);
    return p.b ? p.a : null;
  }

  static public ScanlineBitMatrix toScanlineBitMatrix(Matrix<Boolean> m) {
    if (m == null)
      return null;
    if (m instanceof ScanlineBitMatrix)
      return ((ScanlineBitMatrix) m);
    return new ScanlineBitMatrix(m);
  }

  static public BufferedImage loadImage2(String snippetIDOrURL) {
    return loadBufferedImage(snippetIDOrURL);
  }

  static public BufferedImage loadImage2(File file) {
    return loadBufferedImage(file);
  }

  static public <A extends Concept> Collection<A> conceptsWhere(Class<A> c, Object... params) {
    return findConceptsWhere(c, params);
  }

  static public Collection<Concept> conceptsWhere(String c, Object... params) {
    return findConceptsWhere(c, params);
  }

  static public <A extends Concept> Collection<A> conceptsWhere(Concepts concepts, Class<A> c, Object... params) {
    return findConceptsWhere(concepts, c, params);
  }

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

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

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

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

  static public JTabbedPane jtabs(Object... x) {
    return fillJTabs(swingNu(JTabbedPane.class), x);
  }

  static public void g22_highlightRegion(int[] pixels, ImageSurface is, Gazelle22_ImageToRegions itr, boolean showRegionsAsOutline) {
    g22_highlightRegion(pixels, is, itr, is.mousePosition, showRegionsAsOutline);
  }

  static public void g22_highlightRegion(int[] pixels, ImageSurface is, Gazelle22_ImageToRegions itr, Pt mouse, boolean showRegionsAsOutline) {
    if (mouse != null && itr != null && itr.regions != null) {
      int iHighlightedRegion = itr.regions.regionAt(mouse);
      int color = 0xFF00C000;
      g22_highlightRegion(pixels, is, itr, iHighlightedRegion, color, showRegionsAsOutline);
    }
  }

  static public void g22_highlightRegion(int[] pixels, ImageSurface is, Gazelle22_ImageToRegions itr, int iRegion, int color, boolean showRegionsAsOutline) {
    if (iRegion == 0)
      return;
    if (showRegionsAsOutline) {
      RegionBorder_innerPoints x = new RegionBorder_innerPoints(itr.regions, iRegion);
      gazelle22_highlightRegionOutline(pixels, itr, x);
    } else
      itr.regions.markRegionInPixelArray(pixels, iRegion, color);
  }

  static public void waitUntil(int interval, IF0<Boolean> condition) {
    if (condition == null)
      return;
    while (!condition.get()) sleep(interval);
  }

  static public boolean waitUntil(int interval, double timeout, IF0<Boolean> condition) {
    if (condition == null)
      return false;
    long start = sysNow();
    while (sysNow() < start + toMS(timeout)) if (condition.get())
      return true;
    else
      sleep(interval);
    return false;
  }

  static public <A> boolean comboBoxContainsItem(JComboBox<A> cb, A item) {
    return contains(getComboBoxItems(cb), item);
  }

  static public <A> JComboBox<A> setSelectedItem(A item, JComboBox<A> cb) {
    return selectItem(item, cb);
  }

  static public <A> JComboBox<A> setSelectedItem(JComboBox<A> cb, A item) {
    return selectItem(cb, item);
  }

  static public <A> JList<A> setSelectedItem(JList<A> list, A item) {
    return selectItem(list, item);
  }

  static public JPanel northAndCenterWithMargins(Component n, Component c) {
    return applyDefaultMargin(northAndCenter(withBottomMargin(n), c));
  }

  static public JPanel northAndCenterWithMargins(int margin, Component n, Component c) {
    return applyMargin(margin, northAndCenter(withBottomMargin(margin, n), c));
  }

  static public JComponent withLabel(String label, JComponent component) {
    return westAndCenter(jlabel(label + " "), component);
  }

  static public JComponent withLabel(JComponent label, JComponent component) {
    return westAndCenterWithMargin(label, component);
  }

  static public Component horizontalStrut(int height) {
    return Box.createHorizontalStrut(height);
  }

  static public JPanel withSideMargin(Component c) {
    return withLeftAndRightMargin(c);
  }

  static public JPanel withSideMargin(int w, Component c) {
    return withLeftAndRightMargin(w, c);
  }

  static public JPanel withSideMargin(int w1, int w2, Component c) {
    return withLeftAndRightMargin(w1, w2, c);
  }

  static public int vstackWithSpacing_default = 10;

  static public JPanel vstackWithSpacing(final List parts) {
    return vstackWithSpacing(parts, vstackWithSpacing_default);
  }

  static public JPanel vstackWithSpacing(final List parts, final int spacing) {
    return swing(new F0<JPanel>() {

      public JPanel get() {
        try {
          JPanel panel = new JPanel(new GridBagLayout());
          GridBagConstraints gbc = new GridBagConstraints();
          gbc.weightx = 1;
          gbc.fill = GridBagConstraints.HORIZONTAL;
          gbc.gridwidth = GridBagConstraints.REMAINDER;
          gbc.insets = new Insets(spacing / 2, 0, (spacing + 1) / 2, 0);
          smartAddWithLayout(panel, gbc, toObjectArray(nonNulls(parts)));
          gbc.weighty = 1;
          gbc.insets = new Insets(0, 0, 0, 0);
          panel.add(jrigid(), gbc);
          return panel;
        } catch (Exception __e) {
          throw rethrow(__e);
        }
      }

      public String toString() {
        return "JPanel panel = new JPanel(new GridBagLayout);\r\n    new GridBagConstraints gbc...";
      }
    });
  }

  static public JPanel vstackWithSpacing(Component... parts) {
    return vstackWithSpacing(asList(parts), vstackWithSpacing_default);
  }

  static public JPanel vstackWithSpacing(int spacing, Component... parts) {
    return vstackWithSpacing(asList(parts), spacing);
  }

  static public JLabel jCenteredLabel(String text) {
    return jcenteredLabel(text);
  }

  static public JLabel jCenteredLabel() {
    return jcenteredLabel();
  }

  static public JTextArea jTextArea_noUndo() {
    return jTextArea_noUndo("");
  }

  static public JTextArea jTextArea_noUndo(final String text) {
    return swingNu(JTextArea.class, text);
  }

  static public <A extends JComponent> A awtEveryAndNow(A component, long delay, Object r) {
    swingEvery(component, delay, 0, r);
    return component;
  }

  static public <A extends JComponent> A awtEveryAndNow(A component, double delaySeconds, Object r) {
    return awtEveryAndNow(component, toMS(delaySeconds), r);
  }

  static public void awtEveryAndNow(RootPaneContainer frame, long delay, Object r) {
    swingEvery(frame, delay, 0, r);
  }

  static public Object dm_callStem(Object moduleOrID, String method, Object... args) {
    return call_withVarargs(dm_getStem(moduleOrID), method, args);
  }

  static public JScrollPane jscroll(final Component c) {
    return swing(new F0<JScrollPane>() {

      public JScrollPane get() {
        try {
          return new JScrollPane(c);
        } catch (Exception __e) {
          throw rethrow(__e);
        }
      }

      public String toString() {
        return "return new JScrollPane(c);";
      }
    });
  }

  static public JPanel makeForm3(Object... parts) {
    return withRightMargin(makeForm2(parts));
  }

  static public String javaVersion() {
    return System.getProperty("java.version");
  }

  static public String str_toMB_oneDigit(long l) {
    return formatDouble1(toM(l)) + " MB";
  }

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

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

  static public String or2(String a, String b) {
    return nempty(a) ? a : b;
  }

  static public String or2(String a, String b, String c) {
    return or2(or2(a, b), c);
  }

  static public ClassLoader classLoader(Object o) {
    return classLoaderForObject(o);
  }

  static public String str_toKB(long l) {
    return n2(toK(l)) + " KB";
  }

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

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

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

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

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

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

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

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

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

  static public List<String> _stickyLibs_1013490 = ll("#1400553", "#1400552", "#1004016", "#1004015");

  static public List<Webcam> listWebCams() {
    return Webcam.getWebcams();
  }

  static public <A> JComboBox<A> jTypedComboBox(Collection<A> items) {
    return swing(() -> new JComboBox<A>(toVector(items)));
  }

  static public <A> JComboBox<A> jTypedComboBox(Collection<A> items, A selectedItem) {
    return selectItem(selectedItem, jTypedComboBox(items));
  }

  static public Webcam findWebCamByName(List<Webcam> cams, String name) {
    if (empty(name))
      return null;
    for (Webcam cam : unnull(cams)) if (eqic(cam.getName(), name))
      return cam;
    return null;
  }

  static public AutoCloseable tempInfoBox(String msg) {
    return tempDisposeWindow(infoBox(msg));
  }

  static public <A> A getSelectedItem_typed(JList<A> l) {
    return swing(() -> l.getSelectedValue());
  }

  static public <A> A getSelectedItem_typed(JComboBox<A> cb) {
    return swing(() -> (A) cb.getSelectedItem());
  }

  static public int l(Object[] a) {
    return a == null ? 0 : a.length;
  }

  static public int l(boolean[] a) {
    return a == null ? 0 : a.length;
  }

  static public int l(byte[] a) {
    return a == null ? 0 : a.length;
  }

  static public int l(short[] a) {
    return a == null ? 0 : a.length;
  }

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

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

  static public int l(float[] a) {
    return a == null ? 0 : a.length;
  }

  static public int l(double[] a) {
    return a == null ? 0 : a.length;
  }

  static public int l(char[] a) {
    return a == null ? 0 : a.length;
  }

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

  static public int l(Iterator i) {
    return iteratorCount_int_close(i);
  }

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

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

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

  static public int l(Object o) {
    return o == null ? 0 : o instanceof String ? l((String) o) : o instanceof Map ? l((Map) o) : o instanceof Collection ? l((Collection) o) : o instanceof Object[] ? l((Object[]) o) : o instanceof boolean[] ? l((boolean[]) o) : o instanceof byte[] ? l((byte[]) o) : o instanceof char[] ? l((char[]) o) : o instanceof short[] ? l((short[]) o) : o instanceof int[] ? l((int[]) o) : o instanceof float[] ? l((float[]) o) : o instanceof double[] ? l((double[]) o) : o instanceof long[] ? l((long[]) o) : (Integer) call(o, "size");
  }

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

  static public int l(IntRange r) {
    return r == null ? 0 : r.length();
  }

  static public long l(LongRange r) {
    return r == null ? 0 : r.length();
  }

  static public double l(DoubleRange r) {
    return r == null ? 0 : r.length();
  }

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

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

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

  static public void deleteConcepts(Collection conceptsOrIDs) {
    db_mainConcepts().deleteConcepts(asList(conceptsOrIDs));
  }

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

  static public <A extends Concept> List<A> deleteConcepts(Concepts cc, Class<A> c, Object... params) {
    List<A> l = asList(findConceptsWhere(cc, c, params));
    deleteConcepts(l);
    return l;
  }

  static public <A extends Concept> List<A> deleteConcepts(Class<A> c, IF1<A, Boolean> pred) {
    return deleteConcepts(db_mainConcepts(), c, pred);
  }

  static public <A extends Concept> List<A> deleteConcepts(Concepts cc, Class<A> c, IF1<A, Boolean> pred) {
    var l = filter(list(cc, c), pred);
    deleteConcepts(l);
    return l;
  }

  static public List<Concept> deleteConcepts(Concepts cc) {
    return deleteConcepts(cc, Concept.class);
  }

  static public String nImages(long n) {
    return n2(n, "image");
  }

  static public String nImages(Collection l) {
    return nImages(l(l));
  }

  static public boolean containsTabNameWithoutTrailingCount(JTabbedPane tabs, String name) {
    return indexOfTabNameWithoutTrailingCount(tabs, name) >= 0;
  }

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

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

  static public <A extends Component> A jMinHeight(A c, int h) {
    return jMinHeight(h, c);
  }

  static public <A extends Component> A jMinHeight(int h, A c) {
    Dimension size = c.getMinimumSize();
    c.setMinimumSize(new Dimension(size.width, max(h, size.height)));
    return jPreferHeight(h, c);
  }

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

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

  static public int linesOfCode_javaTok(String text) {
    List<String> tok = javaTok(text);
    int lines = 0;
    boolean codeInCurrentLine = false;
    for (int i = 0; i < l(tok); i++) {
      String t = tok.get(i);
      if (odd(i)) {
        int lTok = l(t);
        for (int j = 0; j < lTok; j++) {
          char c = t.charAt(j);
          if (c == '\n')
            codeInCurrentLine = false;
          else if (!isSpaceEtc(c) && !codeInCurrentLine) {
            codeInCurrentLine = true;
            ++lines;
          }
        }
      } else {
        if (codeInCurrentLine && containsNewLine(t))
          codeInCurrentLine = false;
      }
    }
    return lines;
  }

  static public JPanel withTopRightAndBottomMargin(Component c) {
    return withTopRightAndBottomMargin(defaultMargin(), c);
  }

  static public JPanel withTopRightAndBottomMargin(int w, Component c) {
    return withMargins(w, 0, w, w, c);
  }

  static public JPanel jCenteredRaisedSection(Component c) {
    return jCenteredRaisedSection("", c);
  }

  static public JPanel jCenteredRaisedSection(String title, Component c) {
    return centerSection(jRaisedSection(title, c));
  }

  static public JPanel withSideAndBottomMargin(Component c) {
    return withSideAndBottomMargin(defaultMargin(), c);
  }

  static public JPanel withSideAndBottomMargin(int w, Component c) {
    return swing(() -> {
      JPanel p = marginPanel();
      p.setBorder(BorderFactory.createEmptyBorder(0, w, w, w));
      p.add(c);
      return p;
    });
  }

  static public JSplitPane jvsplit(Component n, Component s) {
    return jvsplit(n, s, 0.5);
  }

  static public JSplitPane jvsplit(Component n, Component s, double splitPoint) {
    return jvsplit(n, s, splitPoint, 0);
  }

  static public JSplitPane jvsplit(Component n, Component s, double splitPoint, int delay) {
    return setSplitPaneOnFirstShowing(swingNu(JSplitPane.class, JSplitPane.VERTICAL_SPLIT, wrap(n), wrap(s)), splitPoint, delay);
  }

  static public JSplitPane jvsplit(double splitPoint, Component n, Component s) {
    return jvsplit(splitPoint, 0, n, s);
  }

  static public JSplitPane jvsplit(double splitPoint, int delay, Component n, Component s) {
    return jvsplit(n, s, splitPoint, delay);
  }

  static public RSyntaxTextAreaWithSearch liveValueRSyntaxTextArea_bothWays(SimpleLiveValue<String> lv) {
    RSyntaxTextAreaWithSearch ta = rSyntaxTextAreaWithSearch();
    bindTextComponentToLiveValue_bothWays(ta.textArea(), lv);
    return ta;
  }

  static public SimpleLiveValue conceptFieldLiveValue(Concept c, String fieldName) {
    Class type = getFieldType(c, fieldName);
    SimpleLiveValue value = new SimpleLiveValue(type, cget(c, fieldName));
    onConceptChangeByClass_notOnAllChanged(c.getClass(), new Runnable() {

      public void run() {
        try {
          Object o = cget(c, fieldName);
          value.set(o);
        } catch (Exception __e) {
          throw rethrow(__e);
        }
      }

      public String toString() {
        return "Object o = cget(c, fieldName);\r\n    value.set(o);";
      }
    });
    value.onChange(new Runnable() {

      public void run() {
        try {
          cset(c, fieldName, value.get());
        } catch (Exception __e) {
          throw rethrow(__e);
        }
      }

      public String toString() {
        return "cset(c, fieldName, value!);";
      }
    });
    return value;
  }

  static public SimpleLiveValue conceptFieldLiveValue(String fieldName, Concept c) {
    return conceptFieldLiveValue(c, fieldName);
  }

  static public <A> LiveValue<A> dm_liveValue(DynModule module, Class type, F0<A> calc) {
    return dm_calculatedLiveValue(module, type, calc);
  }

  static public <A> LiveValue<A> dm_liveValue(Class type, F0<A> calc) {
    return dm_calculatedLiveValue(type, calc);
  }

  static public <A> LiveValue<A> dm_liveValue(Class<A> type, IF0<A> calc) {
    return dm_calculatedLiveValue(type, calc);
  }

  static public LiveValue<Object> dm_liveValue(IF0<?> calc) {
    return dm_calculatedLiveValue(calc);
  }

  static public SimpleLiveValue dm_liveValue(String fieldName) {
    return dm_liveValue(dm_current_mandatory(), fieldName);
  }

  static public SimpleLiveValue dm_liveValue(DynModule module, String fieldName) {
    return dm_fieldLiveValue(module, fieldName);
  }

  static public boolean fileExists(String path) {
    return path != null && new File(path).exists();
  }

  static public boolean fileExists(File f) {
    return f != null && f.exists();
  }

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

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

  static public Rect mouseArea(int w) {
    return mouseArea(w, w);
  }

  static public Rect mouseArea(int w, int h) {
    Point p = mouseLocation();
    return new Rect(p.x - w / 2, p.y - h / 2, w, h);
  }

  static public int screenNrContaining(Pt p) {
    if (p == null)
      return -1;
    return indexOfFirst(allScreenBounds(), screen -> contains(screen, p));
  }

  static public Pt mouseLocationPt() {
    return mousePointer();
  }

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

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

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

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

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

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

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

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

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

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

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

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

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

  static public int first(IntBuffer buf) {
    return buf.get(0);
  }

  static public byte first(ByteBuffer buf) {
    return buf.get(0);
  }

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

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

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

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

  static public <A> A second(List<A> l) {
    return get(l, 1);
  }

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

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

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

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

  static public <A> A second(Producer<A> p) {
    if (p == null)
      return null;
    if (p.next() == null)
      return null;
    return p.next();
  }

  static public char second(String s) {
    return charAt(s, 1);
  }

  static public <A, B> B second(Either<A, B> e) {
    return e == null ? null : e.bOpt();
  }

  static public Rect rectUnion(Rect a, Rect b) {
    if (a == null)
      return b;
    if (b == null)
      return a;
    int x = min(a.x, b.x), y = min(a.y, b.y);
    int x2 = max(a.x + a.w, b.x + b.w), y2 = max(a.y + a.h, b.y + b.h);
    return new Rect(x, y, x2 - x, y2 - y);
  }

  static public double doubleRatio(double x, double y) {
    return y == 0 ? 0 : x / y;
  }

  static public double doubleRatio(Seconds x, Seconds y) {
    return doubleRatio(x.get(), y.get());
  }

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

  static public BufferedImage whiteImage(int w, int h) {
    return newBufferedImage(w, h, Color.white);
  }

  static public BufferedImage whiteImage(int size) {
    return whiteImage(size, size);
  }

  static public int random_incl(int min, int max) {
    return random_incl(min, max, defaultRandomizer());
  }

  static public int random_incl(int min, int max, Random random) {
    return random(min, max + 1, random);
  }

  static public int random_incl(int max) {
    return random(0, max + 1);
  }

  static public Rect translateRect(int x, int y, Rect r) {
    return translateRect(r, x, y);
  }

  static public Rect translateRect(Rect r, int x, int y) {
    return r == null ? null : new Rect(r.x + x, r.y + y, r.w, r.h);
  }

  static public int random(int n) {
    return random(n, defaultRandomGenerator());
  }

  static public int random(int n, Random r) {
    return random(r, n);
  }

  static public int random(Random r, int n) {
    return n <= 0 ? 0 : getRandomizer(r).nextInt(n);
  }

  static public double random(double max) {
    return random() * max;
  }

  static public double random() {
    return defaultRandomGenerator().nextInt(100001) / 100000.0;
  }

  static public double random(double min, double max) {
    return min + random() * (max - min);
  }

  static public int random(int min, int max) {
    return min + random(max - min);
  }

  static public int random(int min, int max, Random r) {
    return random(r, min, max);
  }

  static public int random(Random r, int min, int max) {
    return min + random(r, max - min);
  }

  static public <A> A random(List<A> l) {
    return oneOf(l);
  }

  static public <A> A random(Collection<A> c) {
    if (c instanceof List)
      return random((List<A>) c);
    int i = random(l(c));
    return collectionGet(c, i);
  }

  static public int random(IntRange r) {
    return random(r.start, r.end);
  }

  static public <A, B> Pair<A, B> random(Map<A, B> map) {
    return entryToPair(random(entries(map)));
  }

  static public <A, B extends Number> A lowest(Map<A, B> map) {
    A best = null;
    Number bestScore = null;
    for (A key : keys(map)) {
      Number score = map.get(key);
      if (best == null || cmp(score, bestScore) < 0) {
        best = key;
        bestScore = score;
      }
    }
    return best;
  }

  static public <A> A lowest(Iterable<A> l, IF1<A, Number> f) {
    return lowestByScoreFunction(l, f);
  }

  static public Class __javax;

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

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

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

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

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

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

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

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

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

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

  static public boolean jmenuItem_newThreads = false;

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

  static public JMenuItem jmenuItem(final String text, final Object r) {
    return swing(new F0<JMenuItem>() {

      public JMenuItem get() {
        try {
          Pair<String, Integer> p = jmenu_autoMnemonic(dropPrefix("[disabled] ", text));
          JMenuItem mi = new JMenuItem(p.a);
          if (startsWith(text, "[disabled] "))
            disableMenuItem(mi);
          if (p.b != 0)
            mi.setMnemonic(p.b);
          mi.addActionListener(jmenuItem_newThreads ? actionListenerInNewThread(r) : actionListener(r));
          return mi;
        } catch (Exception __e) {
          throw rethrow(__e);
        }
      }

      public String toString() {
        return "Pair<S, Int> p = jmenu_autoMnemonic(dropPrefix(\"[disabled] \", text));\r\n    JM...";
      }
    });
  }

  static public void dm_watchFields(Collection<String> fields, Runnable onChange) {
    for (String field : unnullForIteration(fields)) dm_watchField(field, onChange);
  }

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

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

  static public int identityHash(Object o) {
    return identityHashCode(o);
  }

  static public boolean isConceptFieldIndexed(Class<? extends Concept> c, String field) {
    return isConceptFieldIndexed(db_mainConcepts(), c, field);
  }

  static public boolean isConceptFieldIndexed(Concepts concepts, Class<? extends Concept> c, String field) {
    return concepts.getFieldIndex(c, field) != null;
  }

  static public void onConceptsChange(Runnable r) {
    onConceptsChange(db_mainConcepts(), r);
  }

  static public void onConceptsChange(Concepts cc, Runnable r) {
    cc.addConceptIndex(simpleConceptIndex(r));
    cc.onAllChanged.add(r);
  }

  static public Pair<JTabbedPane, Integer> enclosingTab(Component _c) {
    return swing(() -> {
      Component c = _c;
      while (c != null) {
        Container p = c.getParent();
        if (p instanceof JTabbedPane)
          return pair(((JTabbedPane) p), ((JTabbedPane) p).indexOfComponent(c));
        c = c.getParent();
      }
      return null;
    });
  }

  static public void setTabTitle(JTabbedPane tabs, int idx, String title) {
    if (tabs != null && idx >= 0) {
      swing(() -> {
        if (idx < tabs.getTabCount())
          tabs.setTitleAt(idx, title);
      });
    }
  }

  static public String appendBracketedCount(int n, String a) {
    return appendBracketed(a, n2(n));
  }

  static public String appendBracketedCount(String a, int n) {
    return appendBracketedCount(n, a);
  }

  static public String getTabTitle(JTabbedPane tabs, int idx) {
    return tabs == null || idx < 0 ? null : swing(() -> idx < tabs.getTabCount() ? tabs.getTitleAt(idx) : null);
  }

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

  static public <A, B> LinkedHashMap<A, B> mapSortedByValue(Map<A, B> map) {
    return orderMapByValue(map);
  }

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

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

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

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

  static public boolean isScreenCoordinateInWindow(Pt p, Component c) {
    Window w = getWindow(c);
    return w != null && w.isShowing() && toRect(boundsOnScreen(w)).contains(p);
  }

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

  static public int colorToIntOpaque(Color c) {
    return c.getRGB() | 0xFF000000;
  }

  static public Color blendColors(double bish, Color a, Color b) {
    return blendColors(a, b, bish);
  }

  static public Color blendColors(Color a, Color b, double bish) {
    bish = normalizeTo0to1(bish);
    return new Color((float) blend(a.getRed() / 255.0, b.getRed() / 255.0, bish), (float) blend(a.getGreen() / 255.0, b.getGreen() / 255.0, bish), (float) blend(a.getBlue() / 255.0, b.getBlue() / 255.0, bish));
  }

  static public Color lightBlue_cache;

  static public Color lightBlue() {
    if (lightBlue_cache == null)
      lightBlue_cache = lightBlue_load();
    return lightBlue_cache;
  }

  static public Color lightBlue_load() {
    return colorFromHex("4169e1");
  }

  static public Set<AutoCloseable> _registerAutoCloseable_set = synchroHashSet();

  static public void _registerAutoCloseable(AutoCloseable c) {
    addIfNotNull(_registerAutoCloseable_set, c);
  }

  static public void cleanMeUp__registerAutoCloseable() {
    closeAutoCloseables(getAndClearList(_registerAutoCloseable_set));
  }

  static public double msToSeconds(long ms) {
    return toSeconds(ms);
  }

  static public double msToSeconds(double ms) {
    return toSeconds(ms);
  }

  static public File imagesDir() {
    return userDir_oneOf_createIfNone("Pictures", "OneDrive/Pictures", "OneDrive/Bilder", "Pictures", "Bilder");
  }

  static public File imagesDir(String sub) {
    return newFile(imagesDir(), sub);
  }

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

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

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

  static public boolean isImageFileName(String s) {
    return eqicOneOf(fileExtension(s), ".png", ".jpg", ".jpeg", ".gif");
  }

  static public boolean isFile(File f) {
    return f != null && f.isFile();
  }

  static public boolean isFile(String path) {
    return isFile(newFile(path));
  }

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

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

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

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

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

  static volatile public boolean ping_pauseAll = false;

  static public int ping_sleep = 100;

  static volatile public boolean ping_anyActions = false;

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

  static public HashMap litmap(Object... x) {
    HashMap map = new HashMap();
    litmap_impl(map, x);
    return map;
  }

  static public void litmap_impl(Map map, Object... x) {
    if (x != null)
      for (int i = 0; i < x.length - 1; i += 2) if (x[i + 1] != null)
        map.put(x[i], x[i + 1]);
  }

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

  static public boolean empty(MultiMap mm) {
    return mm == null || mm.isEmpty();
  }

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

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

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

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

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

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

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

  static public double fraction(double d) {
    return d % 1;
  }

  static public String n_fancy2(long l, String singular, String plural) {
    return formatWithThousandsSeparator(l) + " " + trim(l == 1 ? singular : plural);
  }

  static public String n_fancy2(Collection l, String singular, String plural) {
    return n_fancy2(l(l), singular, plural);
  }

  static public String n_fancy2(Map m, String singular, String plural) {
    return n_fancy2(l(m), singular, plural);
  }

  static public String n_fancy2(Object[] a, String singular, String plural) {
    return n_fancy2(l(a), singular, plural);
  }

  static public String n_fancy2(MultiSet ms, String singular, String plural) {
    return n_fancy2(l(ms), singular, plural);
  }

  static public <A extends JComponent> A setBorder(Border border, A c) {
    if (c != null) {
      swing(() -> {
        c.setBorder(border);
      });
    }
    return c;
  }

  static public <A extends JComponent> A setBorder(A c, Border border) {
    return setBorder(border, c);
  }

  static public JScrollPane withoutViewportBorder(JScrollPane sp) {
    if (sp != null) {
      swing(() -> {
        sp.setViewportBorder(null);
      });
    }
    return sp;
  }

  static public JPanel vstack2(final Object... parts) {
    return swing(new F0<JPanel>() {

      public JPanel get() {
        try {
          JPanel panel = new JPanel(new GridBagLayout());
          GridBagConstraints gbc = new GridBagConstraints();
          gbc.weightx = 1;
          gbc.fill = GridBagConstraints.HORIZONTAL;
          gbc.gridwidth = GridBagConstraints.REMAINDER;
          smartAddWithLayout(panel, gbc, parts);
          gbc.weighty = 1;
          panel.add(jrigid(), gbc);
          return panel;
        } catch (Exception __e) {
          throw rethrow(__e);
        }
      }

      public String toString() {
        return "JPanel panel = new JPanel(new GridBagLayout);\r\n    new GridBagConstraints gbc...";
      }
    });
  }

  static public JPanel smartAddWithLayout(JPanel panel, Object layout, List parts) {
    for (Object o : parts) panel.add(wrapForSmartAdd(o), layout);
    return panel;
  }

  static public JPanel smartAddWithLayout(JPanel panel, Object layout, Object... parts) {
    return smartAddWithLayout(panel, layout, asList(flattenArray2(parts)));
  }

  static public Component jrigid() {
    return javax.swing.Box.createRigidArea(new Dimension(0, 0));
  }

  static public JSpinner liveValueSpinner(SimpleLiveValue<Integer> lv, int min, int max) {
    JSpinner spinner = jSpinner(lv.get(), min, max);
    return bindLiveValueToSpinner(lv, spinner);
  }

  static public JSpinner bindLiveValueToSpinner(SimpleLiveValue<Integer> lv, JSpinner spinner) {
    onChange(spinner, new Runnable() {

      public void run() {
        try {
          lv.set(intFromSpinner(spinner));
        } catch (Exception __e) {
          throw rethrow(__e);
        }
      }

      public String toString() {
        return "lv.set(intFromSpinner(spinner))";
      }
    });
    lv.onChange(new Runnable() {

      public void run() {
        try {
          setSpinnerValue(spinner, lv.get());
        } catch (Exception __e) {
          throw rethrow(__e);
        }
      }

      public String toString() {
        return "setSpinnerValue(spinner, lv!)";
      }
    });
    return spinner;
  }

  static public <A extends JComponent> A toolTipFromLiveValue(LiveValue lv, A c) {
    return bindToolTipToLiveValue(lv, c);
  }

  static public <A> LiveValue<A> dm_transientCalculatedLiveValue(Class type, IF0<A> calc) {
    return dm_transientCalculatedLiveValue(dm_current_mandatory(), type, calc);
  }

  static public <A> LiveValue<A> dm_transientCalculatedLiveValue(DynModule mod, Class type, IF0<A> calc) {
    Lock __0 = mod.lock;
    lock(__0);
    try {
      SimpleLiveValue value = new SimpleLiveValue(type, calc.get());
      mod.onFieldChange(new VF1<String>() {

        public void get(String field) {
          try {
            value.set(calc.get());
          } catch (Exception __e) {
            throw rethrow(__e);
          }
        }

        public String toString() {
          return "value.set(calc!)";
        }
      });
      return value;
    } finally {
      unlock(__0);
    }
  }

  static public LiveValue<Object> dm_transientCalculatedLiveValue(IF0<Object> calc) {
    return dm_transientCalculatedLiveValue(Object.class, calc);
  }

  static public <A extends JLabel> A setHorizontalAlignment(final int pos, final A a) {
    swingCall(a, "setHorizontalAlignment", pos);
    return a;
  }

  static public <A extends AbstractButton> A setHorizontalAlignment(final int pos, final A a) {
    swingCall(a, "setHorizontalAlignment", pos);
    return a;
  }

  static public <A extends JTextField> A setHorizontalAlignment(final int pos, final A a) {
    swingCall(a, "setHorizontalAlignment", pos);
    return a;
  }

  static public JTabbedPane jLeftOrTopTabs(boolean horizontal, Object... x) {
    return horizontal ? jLeftTabs(x) : jtabs(x);
  }

  static public JTabbedPane jLeftOrTopTabs(boolean horizontal, Collection c) {
    return horizontal ? jLeftTabs(c) : jtabs(c);
  }

  static public JFastLogView_noWrap jFastLogView_noWrap() {
    return jFastLogView_noWrap("");
  }

  static public JFastLogView_noWrap jFastLogView_noWrap(String text) {
    return withTypeWriterFont(swingNu(JFastLogView_noWrap.class, text));
  }

  static public String renderStackTrace(StackTraceElement[] st) {
    return stackTraceToString(st);
  }

  static public String renderStackTrace(Throwable e) {
    return stackTraceToString(e);
  }

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

  static public JPanel jRightAlignedButtons(Object... params) {
    List<JComponent> l = new ArrayList();
    for (int i = 0; i < l(params); i += 2) if (params[i] != null)
      if (params[i] instanceof JComponent)
        l.add((JComponent) params[i--]);
      else
        l.add(jbutton((String) params[i], params[i + 1]));
    return jRightAlignedLine(l);
  }

  static public JComponent wrap(Object swingable) {
    return _recordNewSwingComponent(wrap_2(swingable));
  }

  static public JComponent wrap_2(Object swingable) {
    if (swingable == null)
      return null;
    JComponent c;
    if (swingable instanceof Component)
      c = componentToJComponent((Component) swingable);
    else if (swingable instanceof Swingable)
      c = componentToJComponent(((Swingable) swingable).visualize());
    else
      c = componentToJComponent((Component) callOpt(swingable, "swing"));
    if (c instanceof JTable || c instanceof JList || c instanceof JTextArea || c instanceof JEditorPane || c instanceof JTextPane || c instanceof JTree)
      return jscroll(c);
    return c == null ? jlabel(str(swingable)) : c;
  }

  static public Object[] flattenToArray(Object... a) {
    return flattenArray2(a);
  }

  static public boolean isComponentOrSwingable(Object o) {
    if (o instanceof Swingable)
      return true;
    return o instanceof Component;
  }

  static public int tabCount(final JTabbedPane tabs) {
    return tabs == null ? 0 : swing(new F0<Integer>() {

      public Integer get() {
        try {
          return tabs.getTabCount();
        } catch (Exception __e) {
          throw rethrow(__e);
        }
      }

      public String toString() {
        return "return tabs.getTabCount();";
      }
    });
  }

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

  static public void addTabWithToolTip(JTabbedPane tabs, String title, String toolTip, Component c) {
    if (tabs == null)
      return;
    {
      swing(() -> {
        addTab(tabs, title, c);
        if (nempty(toolTip))
          tabs.setToolTipTextAt(tabCount(tabs) - 1, toolTip);
      });
    }
  }

  static public void addTabWithToolTip(JTabbedPane tabs, String title, String toolTip, Swingable c) {
    addTabWithToolTip(tabs, title, toolTip, wrap(c));
  }

  static public <A> List<A> replaceAll(List<A> l, final A a, final A b) {
    return map(l, new F1<A, A>() {

      public A get(A x) {
        try {
          return eq(x, a) ? b : x;
        } catch (Exception __e) {
          throw rethrow(__e);
        }
      }

      public String toString() {
        return "eq(x, a) ? b : x";
      }
    });
  }

  static public String replaceAll(String s, String a, String b) {
    return s == null ? null : s.replaceAll(a, b);
  }

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

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

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

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

  static public JLabel jcenteredLabel(String text) {
    return setHorizontalAlignment(JLabel.CENTER, jLabel(text));
  }

  static public JLabel jcenteredLabel() {
    return jcenteredLabel(" ");
  }

  static public <A extends JComponent> A setToolTipText(final A c, final Object toolTip) {
    if (c == null)
      return null;
    {
      swing(() -> {
        String s = nullIfEmpty(str(toolTip));
        if (neq(s, c.getToolTipText()))
          c.setToolTipText(s);
      });
    }
    return c;
  }

  static public <A extends JComponent> A setToolTipText(Object toolTip, A c) {
    return setToolTipText(c, toolTip);
  }

  static public void setTrayIconToolTip(TrayIcon trayIcon, String toolTip) {
    if (trayIcon != null)
      trayIcon.setToolTip(toolTip);
  }

  static public <A> A parentOfType(Component _c, Class<A> theClass) {
    return swing(() -> {
      Component c = _c;
      while (c != null) {
        if (isInstance(theClass, c))
          return (A) c;
        c = c.getParent();
      }
      return null;
    });
  }

  static public List<Component> tabComponents(final JTabbedPane tabs) {
    final List<Component> l = new ArrayList();
    if (tabs != null) {
      swing(() -> {
        for (int i = 0; i < tabs.getTabCount(); i++) l.add(tabs.getTabComponentAt(i));
      });
    }
    return l;
  }

  static public boolean isGrandChildOf(Component a, Component b) {
    if (a == b)
      return true;
    while ((a = getParent(a)) != null) if (a == b)
      return true;
    return false;
  }

  static public int toInt(Object o) {
    if (o == null)
      return 0;
    if (o instanceof Number)
      return ((Number) o).intValue();
    if (o instanceof String)
      return parseInt((String) o);
    if (o instanceof Boolean)
      return boolToInt((Boolean) o);
    throw fail("woot not int: " + getClassName(o));
  }

  static public int toInt(long l) {
    if (l != (int) l)
      throw fail("Too large for int: " + l);
    return (int) l;
  }

  static public int indexOfTabName(JTabbedPane tabs, String name) {
    return tabs == null ? -1 : swing(() -> tabs.indexOfTab(name));
  }

  static public int selectedTabIndex(final JTabbedPane tabs) {
    return tabs == null ? -1 : swing(new F0<Integer>() {

      public Integer get() {
        try {
          return tabs.getSelectedIndex();
        } catch (Exception __e) {
          throw rethrow(__e);
        }
      }

      public String toString() {
        return "return tabs.getSelectedIndex();";
      }
    });
  }

  static public <A extends JComponent> A focusOnShow(final A a) {
    onFirstComponentShow(a, new Runnable() {

      public void run() {
        try {
          focus(a);
        } catch (Exception __e) {
          throw rethrow(__e);
        }
      }

      public String toString() {
        return "focus(a)";
      }
    });
    return a;
  }

  static public void addMenuItems(JMenu m, Object... x) {
    fillJMenu(m, x);
  }

  static public void addMenuItems(JPopupMenu m, Object... x) {
    fillJPopupMenu(m, x);
  }

  static public JPanel marginPanel() {
    return jtransparent(borderLayoutPanel());
  }

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

  static public String fromLines(Iterable lines) {
    StringBuilder buf = new StringBuilder();
    if (lines != null)
      for (Object line : lines) buf.append(str(line)).append('\n');
    return buf.toString();
  }

  static public String fromLines(String... lines) {
    return fromLines(asList(lines));
  }

  static public IterableIterator<String> toLines(File f) {
    return linesFromFile(f);
  }

  static public List<String> toLines(String s) {
    List<String> lines = new ArrayList<String>();
    if (s == null)
      return lines;
    int start = 0;
    while (true) {
      int i = toLines_nextLineBreak(s, start);
      if (i < 0) {
        if (s.length() > start)
          lines.add(s.substring(start));
        break;
      }
      lines.add(s.substring(start, i));
      if (s.charAt(i) == '\r' && i + 1 < s.length() && s.charAt(i + 1) == '\n')
        i += 2;
      else
        ++i;
      start = i;
    }
    return lines;
  }

  static public int toLines_nextLineBreak(String s, int start) {
    int n = s.length();
    for (int i = start; i < n; i++) {
      char c = s.charAt(i);
      if (c == '\r' || c == '\n')
        return i;
    }
    return -1;
  }

  static public List<String> mapToLines(Map map) {
    List<String> l = new ArrayList();
    for (Object key : keys(map)) l.add(str(key) + " = " + str(map.get(key)));
    return l;
  }

  static public String mapToLines(Map map, Object f) {
    return lines(map(map, f));
  }

  static public String mapToLines(Object f, Map map) {
    return lines(map(map, f));
  }

  static public String mapToLines(Object f, Iterable l) {
    return lines(map(f, l));
  }

  static public <A> String mapToLines(Iterable<A> l, IF1<A, String> f) {
    return mapToLines((Object) f, l);
  }

  static public <A> String mapToLines(IF1<A, String> f, Iterable<A> l) {
    return mapToLines((Object) f, l);
  }

  static public <A, B> String mapToLines(Map<A, B> map, IF2<A, B, String> f) {
    return lines(map(map, f));
  }

  static public <A> String mapToLines(IF1<A, String> f, A data1, A... moreData) {
    return lines(map(f, data1, moreData));
  }

  static public List<String> sortedIgnoreCase(Collection<String> c) {
    List<String> l = cloneList(c);
    Collections.sort(l, caseInsensitiveComparator());
    return l;
  }

  static public double nanosToMicroseconds(double ns) {
    return ns / 1000;
  }

  static public boolean isComponentShowing(final Component c) {
    return c != null && swing(new F0<Boolean>() {

      public Boolean get() {
        try {
          return c.isShowing();
        } catch (Exception __e) {
          throw rethrow(__e);
        }
      }

      public String toString() {
        return "return c.isShowing();";
      }
    });
  }

  static public JButton jimageButton(String imageID, Object action) {
    JButton btn = jbutton("", action);
    btn.setIcon(imageIcon(imageID));
    return btn;
  }

  static public JButton jimageButton(String imageID) {
    return jimageButton(imageID, null);
  }

  static public JButton jimageButton(Image img) {
    return jimageButton(img, null, null);
  }

  static public JButton jimageButton(Image img, String toolTip, Runnable action) {
    var btn = jbutton("", action);
    setButtonImage(btn, img);
    return setToolTip(toolTip, btn);
  }

  static public JButton jimageButton(ImageIcon img, String toolTip, Runnable action) {
    var btn = jbutton("", action);
    setButtonImage(btn, img);
    return setToolTip(toolTip, btn);
  }

  static public BufferedImage scaleImageToWidth(BufferedImage img, int newW) {
    return resizeImage(img, newW);
  }

  static public BufferedImage scaleImageToWidth(int newW, BufferedImage img) {
    return scaleImageToWidth(img, newW);
  }

  static public BufferedImage scaleImageToWidth(int newW, String imageID) {
    return scaleImageToWidth(newW, loadImage2(imageID));
  }

  static public JComboBox jcombobox(final String... items) {
    return swing(new F0<JComboBox>() {

      public JComboBox get() {
        try {
          return new JComboBox(items);
        } catch (Exception __e) {
          throw rethrow(__e);
        }
      }

      public String toString() {
        return "return new JComboBox(items);";
      }
    });
  }

  static public JComboBox jcombobox(Collection<String> items) {
    return jcombobox(toStringArray(items));
  }

  static public JComboBox jcombobox(Collection<String> items, String selectedItem) {
    return selectItem(selectedItem, jcombobox(items));
  }

  static public void selectRow(final JTable table, final int i) {
    if (table != null) {
      swing(() -> {
        if (i >= 0 && i < table.getRowCount()) {
          table.setRowSelectionInterval(i, i);
          scrollRowToVisible(table, i);
        } else
          table.clearSelection();
      });
    }
  }

  static public void selectRow(final JList list, final int i) {
    if (list != null) {
      swing(() -> {
        if (i >= 0 && i < listRowCount(list))
          list.setSelectedIndex(i);
        else
          list.clearSelection();
      });
    }
  }

  static public <A> int jlist_indexOf(JList<A> list, A item) {
    return swing(new F0<Integer>() {

      public Integer get() {
        try {
          ListModel<A> model = list.getModel();
          int n = model.getSize();
          for (int i = 0; i < n; i++) if (eq(model.getElementAt(i), item))
            return i;
          return -1;
        } catch (Exception __e) {
          throw rethrow(__e);
        }
      }

      public String toString() {
        return "ListModel<A> model = list.getModel();\r\n    int n = model.getSize();\r\n    for ...";
      }
    });
  }

  static public List<Integer> countIteratorToList_inclusive(int b) {
    return countIteratorToList_inclusive(0, b);
  }

  static public List<Integer> countIteratorToList_inclusive(int a, int b) {
    return asList(countIterator_inclusive(a, b));
  }

  static public <A> List<A> countIteratorToList_inclusive(int b, IF1<Integer, A> f) {
    return countIteratorToList_inclusive(0, b, f);
  }

  static public <A> List<A> countIteratorToList_inclusive(int a, int b, IF1<Integer, A> f) {
    return asList(countIterator_inclusive(a, b, f));
  }

  static public List<Integer> countIteratorToList_inclusive(int a, int b, int step) {
    return asList(countIterator_inclusive_step(a, b, step));
  }

  static public <A> List<A> countIteratorToList_inclusive(double a, double b, double step, IF1<Double, A> f) {
    return asList(countIterator_inclusive(a, b, step, f));
  }

  static public <A> List<Double> countIteratorToList_inclusive(double a, double b, double step) {
    return asList(countIterator_inclusive_step(a, b, step));
  }

  static public <A> List<A> countIteratorToList_inclusive(IF1<Double, A> f, double a, double b, double step) {
    return asList(countIterator_inclusive_step(a, b, step, f));
  }

  static public <A> List<A> countIteratorToList_inclusive(IF1<Integer, A> f, int a, int b) {
    return countIteratorToList_inclusive(f, a, b, 1);
  }

  static public <A> List<A> countIteratorToList_inclusive(IF1<Integer, A> f, int a, int b, int step) {
    return asList(countIterator_inclusive(a, b, step, f));
  }

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

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

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

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

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

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

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

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

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

  static public JSpinner jSpinner(final int value) {
    return swing(new F0<JSpinner>() {

      public JSpinner get() {
        try {
          JSpinner s = new JSpinner();
          s.setValue(value);
          return jSpinnerCommitOnValidEdit(s);
        } catch (Exception __e) {
          throw rethrow(__e);
        }
      }

      public String toString() {
        return "new JSpinner s;\r\n    s.setValue(value);\r\n    ret jSpinnerCommitOnValidEdit(s);";
      }
    });
  }

  static public JSpinner jSpinner(final int value, final int min, final int max) {
    return swing(new F0<JSpinner>() {

      public JSpinner get() {
        try {
          return jSpinnerCommitOnValidEdit(new JSpinner(new SpinnerNumberModel(value, min, max, 1)));
        } catch (Exception __e) {
          throw rethrow(__e);
        }
      }

      public String toString() {
        return "return jSpinnerCommitOnValidEdit(new JSpinner(new SpinnerNumberModel(value, m...";
      }
    });
  }

  static public List<Integer> powersOfTwoUpTo(int n) {
    IntBuffer l = new IntBuffer();
    int i = 1;
    while (i <= n && i > 0) {
      l.add(i);
      i *= 2;
    }
    return l.asVirtualList();
  }

  static public JSpinner rightAlignSpinner(JSpinner spinner) {
    setHorizontalAlignment(JTextField.RIGHT, getTextFieldFromSpinner(spinner));
    return spinner;
  }

  static public <A> JSpinner jListSpinner(List<A> entries, A defaultValue) {
    return swing(() -> {
      JSpinner s = new JSpinner();
      s.setModel(new SpinnerListModel(entries));
      if (contains(entries, defaultValue))
        setSpinnerValue(s, defaultValue);
      return s;
    });
  }

  static public File makeFileNameUnique_beforeExtension_startWith1_noDot(File f) {
    File orig = f;
    int n = 1;
    do {
      f = appendToFileBaseName(orig, str(n++));
    } while (f.exists());
    return f;
  }

  static public void saveImage(File f, BufferedImage img) {
    if (hasJPEGExtension(f))
      saveJPG(f, img);
    else
      savePNG(f, img);
  }

  static public String appendBracketed(Object o) {
    String b = strOrNull(o);
    return empty(b) ? "" : "" + " (" + b + ")";
  }

  static public String appendBracketed(String a, String b) {
    return a + appendBracketed(b);
  }

  static public String fileInfo(File f) {
    return renderFileInfo(f);
  }

  static public String fileInfo(String f) {
    return renderFileInfo(newFile(f));
  }

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

  static public <A extends Concept> A uniqueConcept(Concepts cc, Class<A> c, Object... params) {
    AutoCloseable __1 = tempDBLock(cc);
    try {
      params = expandParams(c, params);
      A x = findConceptWhere(cc, c, params);
      if (x == null) {
        x = unlisted(c);
        csetAll(x, params);
        cc.register(x);
      } else {
      }
      return x;
    } finally {
      _close(__1);
    }
  }

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

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

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

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

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

  static public int cmpAlphaNum(String a, String b) {
    return alphaNumComparator().compare(a, b);
  }

  static public void onUpdateAndNow(JComponent c, final Object r) {
    onUpdate(c, r);
    callF(r);
  }

  static public void onUpdateAndNow(List<? extends JComponent> l, Object r) {
    for (JComponent c : l) onUpdate(c, r);
    callF(r);
  }

  static public <A extends Concept> Pair<A, Boolean> uniq2(Class<A> c, Object... params) {
    return uniq2(db_mainConcepts(), c, params);
  }

  static public <A extends Concept> Pair<A, Boolean> uniq2(Concepts cc, Class<A> c, Object... params) {
    AutoCloseable __1 = tempDBLock(cc);
    try {
      params = expandParams(c, params);
      A x = findConceptWhere(cc, c, params);
      if (x == null) {
        x = unlisted(c);
        csetAll(x, params);
        cc.register(x);
        return pair(x, true);
      }
      return pair(x, false);
    } finally {
      _close(__1);
    }
  }

  static public boolean loadBufferedImage_useImageCache = true;

  static public BufferedImage loadBufferedImage(String snippetIDOrURLOrFile) {
    try {
      ping();
      if (snippetIDOrURLOrFile == null)
        return null;
      if (isURL(snippetIDOrURLOrFile))
        return imageIO_readURL(snippetIDOrURLOrFile);
      if (isSnippetID(snippetIDOrURLOrFile)) {
        String snippetID = "" + parseSnippetID(snippetIDOrURLOrFile);
        IResourceLoader rl = vm_getResourceLoader();
        if (rl != null)
          return loadBufferedImage(rl.loadLibrary(snippetID));
        File dir = imageSnippetsCacheDir();
        if (loadBufferedImage_useImageCache) {
          dir.mkdirs();
          File file = new File(dir, snippetID + ".png");
          if (file.exists() && file.length() != 0)
            try {
              return ImageIO.read(file);
            } catch (Throwable e) {
              e.printStackTrace();
            }
        }
        String imageURL = snippetImageURL_http(snippetID);
        print("Loading image: " + imageURL);
        BufferedImage image = imageIO_readURL(imageURL);
        if (loadBufferedImage_useImageCache) {
          File tempFile = new File(dir, snippetID + ".tmp." + System.currentTimeMillis());
          ImageIO.write(image, "png", tempFile);
          tempFile.renameTo(new File(dir, snippetID + ".png"));
        }
        return image;
      } else
        return loadBufferedImage(new File(snippetIDOrURLOrFile));
    } catch (Exception __e) {
      throw rethrow(__e);
    }
  }

  static public BufferedImage loadBufferedImage(File file) {
    return loadBufferedImageFile(file);
  }

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

  static public Collection<Concept> findConceptsWhere(String c, Object... params) {
    return findConceptsWhere(db_mainConcepts(), c, params);
  }

  static public <A extends Concept> Collection<A> findConceptsWhere(Concepts concepts, Class<A> c, Object... params) {
    ping();
    params = expandParams(c, params);
    if (concepts.fieldIndices != null)
      for (int i = 0; i < l(params); i += 2) {
        IFieldIndex<A, Object> index = concepts.getFieldIndex(c, (String) params[i]);
        if (index != null) {
          Collection<A> rawList = index.getAll(params[i + 1]);
          params = dropEntryFromParams(params, i);
          if (params == null)
            return rawList;
          List<A> l = new ArrayList();
          for (A x : rawList) if (checkConceptFields(x, params))
            l.add(x);
          return l;
        }
      }
    return filterConcepts(concepts.list(c), params);
  }

  static public Collection<Concept> findConceptsWhere(Concepts concepts, String c, Object... params) {
    return filterConcepts(concepts.list(c), params);
  }

  static public JTabbedPane fillJTabs(final JTabbedPane tabs, final Object... _x) {
    if (tabs == null)
      return null;
    clearTabs(tabs);
    Object[] x = flattenArray2(_x);
    int idx = 0;
    if (get(x, 0) instanceof Integer) {
      idx = asInt(get(x, 0));
      x = dropFirst(x);
      if (empty(x)) {
        x = arrayrep(null, idx);
        idx = 0;
      }
    }
    int n = 0;
    for (int i = 0; i < l(x); i++) {
      ++n;
      Object o = x[i];
      if (isComponentOrSwingable(o))
        addTab(tabs, "Tab " + n, wrap(o));
      else {
        String toolTip = "";
        if (o instanceof WithToolTip) {
          toolTip = ((WithToolTip) o).toolTip();
          o = ((WithToolTip) o).get();
        }
        String name = str(or(o, "Tab " + n));
        Component c;
        if (isComponentOrSwingable(get(x, i + 1)))
          c = wrap(get(x, ++i));
        else
          c = new JPanel();
        addTabWithToolTip(tabs, name, toolTip, wrap(c));
      }
    }
    if (idx != 0)
      tabs.setSelectedIndex(min(tabs.getTabCount() - 1, idx));
    return tabs;
  }

  static public <A> A swingNu(final Class<A> c, final Object... args) {
    return swingConstruct(c, args);
  }

  static public void gazelle22_highlightRegionOutline(int[] pixels, Gazelle22_ImageToRegions itr, RegionBorder_innerPoints x) {
    class X {

      public boolean hole = false;

      public int n;

      public Gazelle22_GradientImage gradientImage = new Gazelle22_GradientImage(itr.posterized);

      public X() {
        gradientImage.init();
        int color = 0xFF008000, holeColor = 0xFFFFB266;
        x.onNewTrace(isHole -> hole = isHole);
        x.onFoundPoint(p -> {
          ++n;
          boolean gradient = gradientImage.isGradientPoint(p.x, p.y);
          int col = hole ? holeColor : color;
          if (gradient)
            if (odd(n))
              return;
          pixels[p.y * itr.regions.w + p.x] = col;
        });
        x.run();
      }
    }
    new X();
  }

  static volatile public boolean sleep_noSleep = false;

  static public void sleep(long ms) {
    ping();
    if (ms < 0)
      return;
    if (isAWTThread() && ms > 100)
      throw fail("Should not sleep on AWT thread");
    try {
      Thread.sleep(ms);
    } catch (Exception e) {
      throw new RuntimeException(e);
    }
  }

  static public void sleep() {
    try {
      if (sleep_noSleep)
        throw fail("nosleep");
      print("Sleeping.");
      sleepQuietly();
    } catch (Exception __e) {
      throw rethrow(__e);
    }
  }

  static public <A> List<A> getComboBoxItems(JComboBox<A> cb) {
    return cb == null ? null : swing(() -> {
      ComboBoxModel<A> model = cb.getModel();
      int n = model.getSize();
      List<A> l = emptyList(n);
      for (int i = 0; i < n; i++) l.add(model.getElementAt(i));
      return l;
    });
  }

  static public JPanel westAndCenter(final Component w, final Component c) {
    return swing(new F0<JPanel>() {

      public JPanel get() {
        try {
          JPanel panel = new JPanel(new BorderLayout());
          panel.add(BorderLayout.WEST, wrap(w));
          panel.add(BorderLayout.CENTER, wrap(c));
          return panel;
        } catch (Exception __e) {
          throw rethrow(__e);
        }
      }

      public String toString() {
        return "JPanel panel = new JPanel(new BorderLayout);\r\n    panel.add(BorderLayout.WEST...";
      }
    });
  }

  static public JPanel westAndCenterWithMargin(Component w, Component c) {
    return westAndCenter(withRightMargin(w), c);
  }

  static public JPanel westAndCenterWithMargin(int margin, Component w, Component c) {
    return westAndCenter(withRightMargin(margin, w), c);
  }

  static public <A> List<A> nonNulls(Iterable<A> l) {
    return withoutNulls(l);
  }

  static public <A> List<A> nonNulls(A[] l) {
    return withoutNulls(l);
  }

  static public <A, B> Map<A, B> nonNulls(Map<A, B> map) {
    return withoutNulls(map);
  }

  static public void swingEvery(JComponent component, long delay, Object r) {
    installTimer(component, delay, r);
  }

  static public void swingEvery(JComponent component, long delay, long firstDelay, Object r) {
    installTimer(component, r, delay, firstDelay);
  }

  static public void swingEvery(RootPaneContainer frame, long delay, Object r) {
    installTimer(frame, delay, r);
  }

  static public void swingEvery(RootPaneContainer frame, long delay, long firstDelay, Object r) {
    installTimer(frame, delay, firstDelay, r);
  }

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

  static public Object dm_getStem(Object moduleOrID) {
    if (isString(moduleOrID) && isIdentifier(((String) moduleOrID)))
      moduleOrID = dm_getService(((String) moduleOrID));
    if (isStringOrIntOrLong(moduleOrID))
      return dm_getStemByID(moduleOrID);
    return or(getOpt(dm_getModule(moduleOrID), "_host"), moduleOrID);
  }

  static public int withRightMargin_defaultWidth = 6;

  static public JPanel withRightMargin(Component c) {
    return withRightMargin(withRightMargin_defaultWidth, c);
  }

  static public JPanel withRightMargin(final int w, final Component c) {
    return swing(new F0<JPanel>() {

      public JPanel get() {
        try {
          JPanel p = marginPanel();
          p.setBorder(BorderFactory.createEmptyBorder(0, 0, 0, w));
          p.add(c);
          return p;
        } catch (Exception __e) {
          throw rethrow(__e);
        }
      }

      public String toString() {
        return "JPanel p = marginPanel();\r\n    p.setBorder(BorderFactory.createEmptyBorder(0,...";
      }
    });
  }

  static public JPanel makeForm2(Object... parts) {
    return makeForm_customLayout(formLayouter1(), parts);
  }

  static public long toM(long l) {
    return (l + 1024 * 1024 - 1) / (1024 * 1024);
  }

  static public String toM(long l, int digits) {
    return formatDouble(toM_double(l), digits);
  }

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

  static public ClassLoader classLoaderForObject(Object o) {
    if (o instanceof ClassLoader)
      return ((ClassLoader) o);
    if (o == null)
      return null;
    return _getClass(o).getClassLoader();
  }

  static public long toK(long l) {
    return (l + 1023) / 1024;
  }

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

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

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

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

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

  static public <A> Vector<A> toVector(A[] array) {
    return new Vector(toList(array));
  }

  static public <A> Vector<A> toVector(Collection<A> l) {
    return l == null ? null : new Vector(l);
  }

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

  static public <A extends Component> A jPreferHeight(int h, A c) {
    Dimension size = c.getPreferredSize();
    c.setPreferredSize(new Dimension(size.width, max(h, size.height)));
    return c;
  }

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

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

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

  static public JPanel withMargins(Component c) {
    return withMargin(c);
  }

  static public JPanel withMargins(int w, Component c) {
    return withMargin(w, c);
  }

  static public JPanel withMargins(int w, int h, Component c) {
    return withMargin(w, h, c);
  }

  static public JPanel withMargins(int top, int left, int bottom, int right, Component c) {
    return withMargin(top, left, bottom, right, c);
  }

  static public JPanel centerSection(JPanel section) {
    if (section != null) {
      swing(() -> {
        Border border = section.getBorder();
        if (border instanceof TitledBorder)
          ((TitledBorder) border).setTitleJustification(TitledBorder.CENTER);
      });
    }
    return section;
  }

  static public RSyntaxTextAreaWithSearch rSyntaxTextAreaWithSearch() {
    RSyntaxTextAreaWithSearch ta = new RSyntaxTextAreaWithSearch();
    ta.textArea().setHighlightCurrentLine(false);
    return ta;
  }

  static public RSyntaxTextAreaWithSearch rSyntaxTextAreaWithSearch(String text) {
    var ta = rSyntaxTextAreaWithSearch();
    ta.setText(text);
    return ta;
  }

  static public <A extends JTextComponent> A bindTextComponentToLiveValue_bothWays(final A tc, final SimpleLiveValue<String> lv) {
    bindLiveValueListenerToComponent(tc, lv, new Runnable() {

      public void run() {
        try {
          setTextKeepCaret(tc, lv.get());
        } catch (Exception __e) {
          throw rethrow(__e);
        }
      }

      public String toString() {
        return "setTextKeepCaret(tc, lv!)";
      }
    });
    onChange(tc, new Runnable() {

      public void run() {
        try {
          lv.set(getText(tc));
        } catch (Exception __e) {
          throw rethrow(__e);
        }
      }

      public String toString() {
        return "lv.set(getText(tc))";
      }
    });
    return tc;
  }

  static public AutoCloseable onConceptChangeByClass_notOnAllChanged(Class type, Runnable r) {
    return onConceptChangeByClass_notOnAllChanged(db_mainConcepts(), type, r);
  }

  static public AutoCloseable onConceptChangeByClass_notOnAllChanged(Concepts cc, Class type, Runnable r) {
    return tempAddConceptIndex(cc, new IConceptIndex() {

      public void update(Concept c) {
        if (instanceOf(c, type))
          pcallF(r);
      }

      public void remove(Concept c) {
        if (instanceOf(c, type))
          pcallF(r);
      }
    });
  }

  static public <A extends Concept> AutoCloseable onConceptChangeByClass_notOnAllChanged(Class<A> type, IVF1<A> r) {
    return onConceptChangeByClass_notOnAllChanged(db_mainConcepts(), type, r);
  }

  static public <A extends Concept> AutoCloseable onConceptChangeByClass_notOnAllChanged(Concepts cc, Class<A> type, IVF1<A> r) {
    return tempAddConceptIndex(cc, new IConceptIndex() {

      public void update(Concept c) {
        if (instanceOf(c, type))
          pcallF(r, (A) c);
      }

      public void remove(Concept c) {
        if (instanceOf(c, type))
          pcallF(r, (A) c);
      }
    });
  }

  static public Point mouseLocation() {
    return getMouseLocation();
  }

  static public int indexOfFirst(List l, Object pred) {
    return indexOfPred(l, pred);
  }

  static public <A, B> int indexOfFirst(List<A> l, IF1<A, B> pred) {
    return indexOfPred(l, pred);
  }

  static public Pt mousePointer() {
    return new Pt(getMouseLocation());
  }

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

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

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

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

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

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

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

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

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

  static public char charAt(String s, int i) {
    return s != null && i >= 0 && i < s.length() ? s.charAt(i) : '\0';
  }

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

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

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

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

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

  static public BufferedImage newBufferedImage(int w, int h) {
    return new BufferedImage(w, h, BufferedImage.TYPE_INT_RGB);
  }

  static public BufferedImage newBufferedImage(int w, int h, RGB rgb) {
    return newBufferedImage(w, h, rgb.getColor());
  }

  static public BufferedImage newBufferedImage(int w, int h, Color color) {
    BufferedImage img = newBufferedImage(w, h);
    Graphics2D g = img.createGraphics();
    g.setColor(or(color, Color.white));
    g.fillRect(0, 0, w, h);
    return img;
  }

  static public BufferedImage newBufferedImage(Pt p, Color color) {
    return newBufferedImage(p.x, p.y, color);
  }

  static public BufferedImage newBufferedImage(int w, int h, int[] pixels) {
    return intArrayToBufferedImage(pixels, w, h);
  }

  static public Random defaultRandomizer() {
    return defaultRandomGenerator();
  }

  static public Random defaultRandomGenerator() {
    {
      Random r = customRandomizerForThisThread();
      if (r != null)
        return r;
    }
    return ThreadLocalRandom.current();
  }

  static public Random getRandomizer(Random r) {
    return r != null ? r : defaultRandomGenerator();
  }

  static public <A> A oneOf(List<A> l) {
    if (empty(l))
      return null;
    int n = l.size();
    return n == 1 ? first(l) : l.get(defaultRandomizer().nextInt(n));
  }

  static public char oneOf(String s) {
    return empty(s) ? '?' : s.charAt(random(l(s)));
  }

  static public String oneOf(String... l) {
    return oneOf(asList(l));
  }

  static public <A> A collectionGet(Collection<A> c, int idx) {
    if (c == null || idx < 0 || idx >= l(c))
      return null;
    if (c instanceof List)
      return listGet((List<A>) c, idx);
    Iterator<A> it = c.iterator();
    for (int i = 0; i < idx; i++) if (it.hasNext())
      it.next();
    else
      return null;
    return it.hasNext() ? it.next() : null;
  }

  static public <A, B> Pair<A, B> entryToPair(Map.Entry<A, B> e) {
    return mapEntryToPair(e);
  }

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

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

  static public Set keys(Object map) {
    return keys((Map) map);
  }

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

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

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

  static public <A> A lowestByScoreFunction(Iterable<A> l, IF1<A, Number> f) {
    Lowest<A> lowest = new Lowest();
    for (A a : unnull(l)) {
      Number score = callF(f, a);
      if (score != null)
        lowest.put(a, toDouble(score));
    }
    return lowest.get();
  }

  static public void _onJavaXSet() {
  }

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

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

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

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

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

  static public Pair<String, Integer> jmenu_autoMnemonic(String s) {
    int i = indexOf(s, '&');
    if (i >= 0 && i < l(s) && isLetterOrDigit(s.charAt(i + 1)))
      return pair(substring(s, 0, i) + substring(s, i + 1), (int) s.charAt(i + 1));
    return pair(s, 0);
  }

  static public String dropPrefix(String prefix, String s) {
    return s == null ? null : s.startsWith(prefix) ? s.substring(l(prefix)) : s;
  }

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

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

  static public ActionListener actionListenerInNewThread(final Object runnable, final Object instanceToHold) {
    if (runnable instanceof ActionListener)
      return (ActionListener) runnable;
    return new java.awt.event.ActionListener() {

      public void actionPerformed(java.awt.event.ActionEvent _evt) {
        try {
          startThread("Action Listener", new Runnable() {

            public void run() {
              try {
                AutoCloseable __1 = holdInstance(instanceToHold);
                try {
                  callF(runnable);
                } finally {
                  _close(__1);
                }
              } catch (Exception __e) {
                throw rethrow(__e);
              }
            }

            public String toString() {
              return "AutoCloseable __1 = holdInstance(instanceToHold); try {\r\n      callF(runnable...";
            }
          });
        } catch (Throwable __e) {
          messageBox(__e);
        }
      }
    };
  }

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

  static public ActionListener actionListener(final Object runnable, final Object instanceToHold) {
    if (runnable instanceof ActionListener)
      return (ActionListener) runnable;
    final Object info = _threadInfo();
    return new java.awt.event.ActionListener() {

      public void actionPerformed(java.awt.event.ActionEvent _evt) {
        try {
          _threadInheritInfo(info);
          AutoCloseable __1 = holdInstance(instanceToHold);
          try {
            pcallF(runnable);
          } finally {
            _close(__1);
          }
        } catch (Throwable __e) {
          messageBox(__e);
        }
      }
    };
  }

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

  static public IConceptIndex simpleConceptIndex(final Runnable r) {
    return new IConceptIndex() {

      public void update(Concept c) {
        pcallF(r);
      }

      public void remove(Concept c) {
        pcallF(r);
      }
    };
  }

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

  static public <A, B> LinkedHashMap<A, B> orderMapByValue(final Map<A, B> map) {
    List<A> l = new ArrayList(map.keySet());
    sort(l, mapComparator(map));
    LinkedHashMap<A, B> map2 = litorderedmap();
    for (A a : l) map2.put(a, map.get(a));
    return map2;
  }

  static volatile public PersistableThrowable lastException_lastException;

  static public PersistableThrowable lastException() {
    return lastException_lastException;
  }

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

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

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

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

  static public Window getWindow(Object o) {
    if (!(o instanceof Component))
      return null;
    return swing(() -> {
      Component c = (Component) o;
      while (c != null) {
        if (c instanceof Window)
          return ((Window) c);
        c = c.getParent();
      }
      return null;
    });
  }

  static public double normalizeTo0to1(double x) {
    return Math.min(Math.max(x, 0), 1);
  }

  static public java.awt.Color colorFromHex(String hex) {
    return awtColor(hex);
  }

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

  static public void closeAutoCloseables(Collection<AutoCloseable> l) {
    if (l != null)
      for (AutoCloseable c : l) {
        try {
          c.close();
        } catch (Throwable __e) {
          printStackTrace(__e);
        }
      }
  }

  static public File userDir_oneOf_createIfNone(String ifNone, String... names) {
    return or(userDir_oneOf(names), userDir(ifNone));
  }

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

  static public String fileExtension(File f) {
    if (f == null)
      return null;
    return fileExtension(f.getName());
  }

  static public String fileExtension(String s) {
    return substring(s, smartLastIndexOf(s, '.'));
  }

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

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

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

  static public String formatWithThousandsSeparator(long l) {
    return NumberFormat.getInstance(new Locale("en_US")).format(l);
  }

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

  static public String trim(String s) {
    return s == null ? null : s.trim();
  }

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

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

  static public void setSpinnerValue(JSpinner s, int value) {
    setSpinnerValue(s, (Integer) value);
  }

  static public void setSpinnerValue(JSpinner s, Object value) {
    try {
      if (s != null) {
        swing(() -> {
          s.setValue(value);
        });
      }
    } catch (Throwable __e) {
      printStackTrace(__e);
    }
  }

  static public <A extends JComponent> A bindToolTipToLiveValue(LiveValue lv, A c) {
    bindLiveValueListenerToComponent(c, lv, new Runnable() {

      public void run() {
        try {
          setToolTipText(c, strOrNull(lv.get()));
        } catch (Exception __e) {
          throw rethrow(__e);
        }
      }

      public String toString() {
        return "setToolTipText(c, strOrNull(lv!))";
      }
    });
    return c;
  }

  static public void lock(Lock lock) {
    try {
      ping();
      if (lock == null)
        return;
      try {
        vmBus_send("locking", lock, "thread", currentThread());
        lock.lockInterruptibly();
        vmBus_send("locked", lock, "thread", currentThread());
      } catch (InterruptedException e) {
        Object reason = vm_threadInterruptionReasonsMap().get(currentThread());
        print("Locking interrupted! Reason: " + strOr(reason, "Unknown"));
        printStackTrace(e);
        rethrow(e);
      }
    } catch (Exception __e) {
      throw rethrow(__e);
    }
  }

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

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

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

  static public void unlock(Lock lock, String msg) {
    if (lock == null)
      return;
    lock.unlock();
    vmBus_send("unlocked", lock, "thread", currentThread());
    print("Unlocked: " + msg);
  }

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

  static public Object swingCall(final Object o, final String method, final Object... args) {
    return swing(new F0<Object>() {

      public Object get() {
        try {
          return call(o, method, args);
        } catch (Exception __e) {
          throw rethrow(__e);
        }
      }

      public String toString() {
        return "return call(o, method, args);";
      }
    });
  }

  static public JTabbedPane jLeftTabs(Object... x) {
    JTabbedPane tabs = jtabs(x);
    tabs.setTabPlacement(JTabbedPane.LEFT);
    return tabs;
  }

  static public JTabbedPane jLeftTabs(Collection c) {
    return jLeftTabs(toObjectArray(c));
  }

  static public String stackTraceToString(StackTraceElement[] st) {
    return lines(st);
  }

  static public String stackTraceToString(Throwable e) {
    return getStackTrace_noRecord(e);
  }

  static public JPanel jRightAlignedLine(Component... components) {
    return jrightAlignedLine(components);
  }

  static public JPanel jRightAlignedLine(List<? extends Component> components) {
    return jrightAlignedLine(components);
  }

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

  static public JComponent componentToJComponent(Component c) {
    if (c instanceof JComponent)
      return (JComponent) c;
    if (c instanceof JFrame)
      return ((JFrame) c).getRootPane();
    if (c == null)
      return null;
    throw fail("boohoo " + getClassName(c));
  }

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

  static public JLabel jLabel(String text) {
    return jlabel(text);
  }

  static public JLabel jLabel() {
    return jlabel();
  }

  static public String nullIfEmpty(String s) {
    return isEmpty(s) ? null : s;
  }

  static public <A, B> Map<A, B> nullIfEmpty(Map<A, B> map) {
    return isEmpty(map) ? null : map;
  }

  static public <A> List<A> nullIfEmpty(List<A> l) {
    return isEmpty(l) ? null : l;
  }

  static public boolean isInstance(Class type, Object arg) {
    return type.isInstance(arg);
  }

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

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

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

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

  static public <A extends JComponent> A onFirstComponentShow(final A component, final Runnable onShow) {
    {
      swing(() -> {
        component.addAncestorListener(new AncestorListener() {

          public void ancestorAdded(AncestorEvent event) {
            component.removeAncestorListener(this);
            pcallF(onShow);
          }

          public void ancestorRemoved(AncestorEvent event) {
          }

          public void ancestorMoved(AncestorEvent event) {
          }
        });
      });
    }
    return component;
  }

  static public <A extends JComponent> A focus(final A a) {
    if (a != null)
      swingLater(new Runnable() {

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

        public String toString() {
          return "a.requestFocus();";
        }
      });
    return a;
  }

  static public void fillJMenu(final JMenu m, Object... x) {
    if (x == null)
      return;
    for (int i = 0; i < l(x); i++) {
      Object o = x[i], y = get(x, i + 1);
      if (o instanceof List)
        fillJMenu(m, asArray((List) o));
      else if (isMenuSeparatorIndicator(o)) {
        if (menuItemCount(m) != 0)
          m.addSeparator();
      } else if (o instanceof LiveValue && ((LiveValue) o).getType() == String.class && isRunnableX(y)) {
        final LiveValue<String> lv = (LiveValue<String>) o;
        final JMenuItem mi = jmenuItem(or2(unCurlyBracket(lv.get()), "..."), y);
        bindLiveValueListenerToComponent(mi, lv, new Runnable() {

          public void run() {
            try {
              String s = lv.get();
              if (isCurlyBracketed(s)) {
                setEnabled(mi, false);
                s = unCurlyBracket(s);
              } else
                setEnabled(mi, true);
              setText(mi, s);
              revalidate(m);
            } catch (Exception __e) {
              throw rethrow(__e);
            }
          }

          public String toString() {
            return "String s = lv!;\r\n        if (isCurlyBracketed(s)) {\r\n          setEnabled(mi,...";
          }
        });
        print("bound live value " + lv + " to menu item " + mi);
        m.add(mi);
        ++i;
      } else if (o instanceof String && isRunnableX(y)) {
        m.add(jmenuItem((String) o, y));
        ++i;
      } else if (o instanceof JMenuItem)
        m.add((JMenuItem) o);
      else if (o instanceof String || o instanceof Action || o instanceof Component)
        call(m, "add", o);
      else if (o == null && y instanceof Runnable)
        ++i;
      else if (o != null)
        print("Unknown menu item: " + o);
    }
  }

  static public <A extends JComponent> A jtransparent(final A a) {
    {
      swing(() -> {
        a.setOpaque(false);
      });
    }
    return a;
  }

  static public JPanel borderLayoutPanel() {
    return jpanel(new BorderLayout());
  }

  static public Runnable addThreadInfoToRunnable(final Object r) {
    final Object info = _threadInfo();
    return info == null ? asRunnable(r) : new Runnable() {

      public void run() {
        try {
          _inheritThreadInfo(info);
          callF(r);
        } catch (Exception __e) {
          throw rethrow(__e);
        }
      }

      public String toString() {
        return "_inheritThreadInfo(info); callF(r);";
      }
    };
  }

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

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

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

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

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

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

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

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

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

  static public Symbol emptySymbol_value;

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

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

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

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

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

  static public int imageIcon_cacheSize = 10;

  static public boolean imageIcon_verbose = false;

  static public Map<String, ImageIcon> imageIcon_cache;

  static public Lock imageIcon_lock = lock();

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

  static public ImageIcon imageIcon(String imageID) {
    try {
      if (imageID == null)
        return null;
      Lock __0 = imageIcon_lock;
      lock(__0);
      try {
        if (imageIcon_cache == null)
          imageIcon_cache = new MRUCache(imageIcon_cacheSize);
        imageID = fsI(imageID);
        ImageIcon ii = imageIcon_cache.get(imageID);
        if (ii == null) {
          if (imageIcon_verbose)
            print("Loading image icon: " + imageID);
          File f = loadBinarySnippet(imageID);
          Boolean b = imageIcon_fixGIF.get();
          if (!isFalse(b))
            ii = new ImageIcon(loadBufferedImageFixingGIFs(f));
          else
            ii = new ImageIcon(f.toURI().toURL());
        } else
          imageIcon_cache.remove(imageID);
        imageIcon_cache.put(imageID, ii);
        return ii;
      } finally {
        unlock(__0);
      }
    } catch (Exception __e) {
      throw rethrow(__e);
    }
  }

  static public ImageIcon imageIcon(File f) {
    try {
      return new ImageIcon(f.toURI().toURL());
    } catch (Exception __e) {
      throw rethrow(__e);
    }
  }

  static public ImageIcon imageIcon(Image img) {
    return new ImageIcon(img);
  }

  static public ImageIcon imageIcon(RGBImage img) {
    return imageIcon(img.getBufferedImage());
  }

  static public JButton setButtonImage(Icon img, JButton btn) {
    btn.setIcon(img);
    return btn;
  }

  static public JButton setButtonImage(Image img, JButton btn) {
    btn.setIcon(imageIcon(img));
    return btn;
  }

  static public JButton setButtonImage(JButton btn, Image img) {
    return setButtonImage(img, btn);
  }

  static public JButton setButtonImage(JButton btn, Icon img) {
    return setButtonImage(img, btn);
  }

  static public BufferedImage resizeImage(BufferedImage img, int newW, int newH) {
    return resizeImage(img, newW, newH, Image.SCALE_SMOOTH);
  }

  static public BufferedImage resizeImage(BufferedImage img, int newW, int newH, int scaleType) {
    if (newW == img.getWidth() && newH == img.getHeight())
      return img;
    Image tmp = img.getScaledInstance(newW, newH, scaleType);
    BufferedImage dimg = new BufferedImage(newW, newH, BufferedImage.TYPE_INT_ARGB);
    Graphics2D g2d = dimg.createGraphics();
    g2d.drawImage(tmp, 0, 0, null);
    g2d.dispose();
    return dimg;
  }

  static public BufferedImage resizeImage(BufferedImage img, int newW) {
    int newH = iround(img.getHeight() * (double) newW / img.getWidth());
    return resizeImage(img, newW, newH);
  }

  static public BufferedImage resizeImage(int newW, BufferedImage img) {
    return resizeImage(img, newW);
  }

  static public String[] toStringArray(Collection<String> c) {
    String[] a = new String[l(c)];
    Iterator<String> it = c.iterator();
    for (int i = 0; i < l(a); i++) a[i] = it.next();
    return a;
  }

  static public String[] toStringArray(Object o) {
    if (o instanceof String[])
      return (String[]) o;
    else if (o instanceof Collection)
      return toStringArray((Collection<String>) o);
    else
      throw fail("Not a collection or array: " + getClassName(o));
  }

  static public void scrollRowToVisible(JTable t, int rowIndex) {
    int colIndex = 0;
    if (!(t.getParent() instanceof JViewport))
      return;
    JViewport viewport = (JViewport) t.getParent();
    Rectangle rect = t.getCellRect(rowIndex, colIndex, true);
    Rectangle viewRect = viewport.getViewRect();
    int x = viewRect.x;
    int y = viewRect.y;
    if (rect.x >= viewRect.x && rect.x <= (viewRect.x + viewRect.width - rect.width)) {
    } else if (rect.x < viewRect.x) {
      x = rect.x;
    } else if (rect.x > (viewRect.x + viewRect.width - rect.width)) {
      x = rect.x - viewRect.width + rect.width;
    }
    if (rect.y >= viewRect.y && rect.y <= (viewRect.y + viewRect.height - rect.height)) {
    } else if (rect.y < viewRect.y) {
      y = rect.y;
    } else if (rect.y > (viewRect.y + viewRect.height - rect.height)) {
      y = rect.y - viewRect.height + rect.height;
    }
    viewport.setViewPosition(new Point(x, y));
  }

  static public int listRowCount(JList list) {
    return list == null ? 0 : swing(new F0<Integer>() {

      public Integer get() {
        try {
          return list.getModel().getSize();
        } catch (Exception __e) {
          throw rethrow(__e);
        }
      }

      public String toString() {
        return "return list.getModel().getSize();";
      }
    });
  }

  static public IterableIterator<Integer> countIterator_inclusive(final int a, final int b) {
    return countIterator_exclusive(a, b + 1);
  }

  static public <A> IterableIterator<A> countIterator_inclusive(int a, int b, IF1<Integer, A> f) {
    return countIterator_inclusive(a, b, 1, f);
  }

  static public <A> IterableIterator<A> countIterator_inclusive(int a, int b, int step, IF1<Integer, A> f) {
    return countIterator_inclusive_step(a, b, 1, f);
  }

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

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

      public int i = a;

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

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

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

      public double i = a;

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

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

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

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

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

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

  static public Object pcallFunction(Object f, Object... args) {
    try {
      return callFunction(f, args);
    } catch (Throwable __e) {
      printStackTrace(__e);
    }
    return null;
  }

  static public JSpinner jSpinnerCommitOnValidEdit(JSpinner spinner) {
    var tf = getTextFieldFromSpinner(spinner);
    if (tf != null) {
      swing(() -> {
        DefaultFormatter formatter = (DefaultFormatter) (tf.getFormatter());
        if (formatter != null)
          formatter.setCommitsOnValidEdit(true);
      });
    }
    return spinner;
  }

  static public JFormattedTextField getTextFieldFromSpinner(JSpinner spinner) {
    return spinner == null ? null : swing(() -> ((JSpinner.DefaultEditor) spinner.getEditor()).getTextField());
  }

  static public boolean hasJPEGExtension(File f) {
    return ewicOneOf(fileName(f), ".jpg", ".jpeg");
  }

  static public void saveJPG(BufferedImage img, File file) {
    try {
      if (!ImageIO.write(img, "jpeg", mkdirsFor(file))) {
        print("Reconstructing image for saving JPEG");
        img = reconstructBufferedImage(img);
        if (!ImageIO.write(img, "jpeg", file))
          throw fail("Couldn't write JPEG: " + file + " (" + img + ")");
      }
      vmBus_send("wroteFile", file);
    } catch (Exception __e) {
      throw rethrow(__e);
    }
  }

  static public void saveJPG(File file, BufferedImage img) {
    try {
      saveJPG(img, file);
    } catch (Exception __e) {
      throw rethrow(__e);
    }
  }

  static public void savePNG(BufferedImage img, File file) {
    try {
      File tempFile = new File(file.getPath() + "_temp");
      CriticalAction ca = beginCriticalAction("Save " + f2s(file));
      try {
        ImageIO.write(img, "png", mkdirsFor(tempFile));
        file.delete();
        tempFile.renameTo(file);
      } finally {
        ca.done();
      }
    } catch (Exception __e) {
      throw rethrow(__e);
    }
  }

  static public void savePNG(String file, BufferedImage img) {
    savePNG(toFile(file), img);
  }

  static public void savePNG(File file, BufferedImage img) {
    savePNG(img, file);
  }

  static public void savePNG(File file, RGBImage img) {
    savePNG(file, img.getBufferedImage());
  }

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

  static public AutoCloseable tempDBLock(Concepts concepts) {
    return tempLock(concepts.lock);
  }

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

  static public <A extends Concept> Object[] expandParams(Class<A> c, Object[] params) {
    if (l(params) == 1)
      params = new Object[] { singleFieldName(c), params[0] };
    else
      warnIfOddCount(params);
    return params;
  }

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

  static public <A extends Concept> A findConceptWhere(Concepts concepts, Class<A> c, Object... params) {
    ping();
    params = expandParams(c, params);
    if (concepts.fieldIndices != null)
      for (int i = 0; i < l(params); i += 2) {
        IFieldIndex<A, Object> index = concepts.getFieldIndex(c, (String) params[i]);
        if (index != null) {
          for (A x : index.getAll(params[i + 1])) if (checkConceptFields(x, params))
            return x;
          return null;
        }
      }
    for (A x : concepts.list(c)) if (checkConceptFields(x, params))
      return x;
    return null;
  }

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

  static public <A extends Concept> A unlisted(Class<A> c, Object... args) {
    concepts_unlisted.set(true);
    try {
      return nuObject(c, args);
    } finally {
      concepts_unlisted.set(null);
    }
  }

  static public Concept unlisted(String name, Object... args) {
    Class<? extends Concept> cc = findClass(name);
    concepts_unlisted.set(true);
    try {
      return cc != null ? nuObject(cc) : new Concept(name);
    } finally {
      concepts_unlisted.set(null);
    }
  }

  static public int csetAll(Concept c, Object... values) {
    return cset(c, values);
  }

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

  static public int csetAll(Concept c, Map<String, Object> values) {
    int n = 0;
    for (Map.Entry<? extends String, ? extends Object> __0 : _entrySet(values)) {
      String field = __0.getKey();
      Object value = __0.getValue();
      n += cset(c, field, value);
    }
    return n;
  }

  static public AlphanumComparator alphaNumComparator_instance;

  static public Comparator<String> alphaNumComparator() {
    if (alphaNumComparator_instance == null)
      alphaNumComparator_instance = new AlphanumComparator();
    return alphaNumComparator_instance;
  }

  static public boolean isURL(String s) {
    return startsWithOneOf(s, "http://", "https://", "file:");
  }

  static public BufferedImage imageIO_readURL(String url) {
    try {
      return ImageIO.read(new URL(url));
    } catch (Exception __e) {
      throw rethrow(__e);
    }
  }

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

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

  static public IResourceLoader vm_getResourceLoader() {
    return proxy(IResourceLoader.class, vm_generalMap_get("_officialResourceLoader"));
  }

  static public File imageSnippetsCacheDir() {
    return javaxCachesDir("Image-Snippets");
  }

  static public String snippetImageURL_http(String snippetID) {
    return snippetImageURL_http(snippetID, "png");
  }

  static public String snippetImageURL_http(String snippetID, String contentType) {
    return replacePrefix("https://", "http://", snippetImageURL(snippetID, contentType)).replace(":8443", ":8080");
  }

  static public BufferedImage loadBufferedImageFile(File file) {
    try {
      return isFile(file) ? ImageIO.read(file) : null;
    } catch (Exception __e) {
      throw rethrow(__e);
    }
  }

  static public Object[] dropEntryFromParams(Object[] params, int i) {
    int n = l(params);
    if (i < 0 || i >= n)
      return params;
    if (n == 2)
      return null;
    Object[] p = new Object[n - 2];
    System.arraycopy(params, 0, p, 0, i);
    System.arraycopy(params, i + 2, p, i, n - i - 2);
    return p;
  }

  static public boolean checkConceptFields(Concept x, Object... data) {
    for (int i = 0; i < l(data); i += 2) if (neq(cget(x, (String) data[i]), deref(data[i + 1])))
      return false;
    return true;
  }

  static public <A extends Concept> List<A> filterConcepts(List<A> list, Object... params) {
    if (empty(params))
      return list;
    List<A> l = new ArrayList();
    for (A x : list) if (checkConceptFields(x, params))
      l.add(x);
    return l;
  }

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

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

  static public Object[] arrayrep(Object a, int n) {
    return asArray(repeat(a, n));
  }

  static public <A> A swingConstruct(final Class<A> c, final Object... args) {
    return swing(new F0<A>() {

      public A get() {
        try {
          return nuObject(c, args);
        } catch (Exception __e) {
          throw rethrow(__e);
        }
      }

      public String toString() {
        return "return nuObject(c, args);";
      }
    });
  }

  static public Object sleepQuietly_monitor = new Object();

  static public void sleepQuietly() {
    try {
      assertFalse(isAWTThread());
      synchronized (sleepQuietly_monitor) {
        sleepQuietly_monitor.wait();
      }
    } catch (Exception __e) {
      throw rethrow(__e);
    }
  }

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

  static public <A, B> Map<A, B> withoutNulls(Map<A, B> map) {
    Map<A, B> map2 = similarEmptyMap(map);
    for (A a : keys(map)) if (a != null) {
      B b = map.get(a);
      if (b != null)
        map2.put(a, b);
    }
    return map2;
  }

  static public <A> List<A> withoutNulls(A[] l) {
    List<A> l2 = new ArrayList();
    if (l != null)
      for (A a : l) if (a != null)
        l2.add(a);
    return l2;
  }

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

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

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

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

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

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

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

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

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

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

  static public Object dm_getStemByID(Object id) {
    return dm_callOS("getModuleByID", str(id));
  }

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

  static public JPanel makeForm_customLayout(final F1<Container, Dimension> layouter, final Object... parts) {
    return makeForm_customArrangement(new F1<List<JComponent>, JPanel>() {

      public JPanel get(List<JComponent> components) {
        try {
          return customLayoutPanel(layouter, components);
        } catch (Exception __e) {
          throw rethrow(__e);
        }
      }

      public String toString() {
        return "customLayoutPanel(layouter, components)";
      }
    }, parts);
  }

  static public int formLayouter1_yPlus = 5;

  static public int formLayouter1_fixer2 = 0;

  static public F1<Container, Dimension> formLayouter1() {
    final int yplus = formLayouter1_yPlus, fixer2 = formLayouter1_fixer2;
    return new F1<Container, Dimension>() {

      public Dimension get(Container parent) {
        try {
          List<Component> l = getComponents(parent);
          BitSet bigOnes = new BitSet();
          for (int i = 0; i < l(l); i++) if (containsATextArea(l.get(i)))
            add(bigOnes, i);
          int nBigOnes = bigOnes.cardinality();
          int mandatoryHeight = totalPreferredHeight(listWithoutIndicesInBitSet(l, bigOnes));
          int gap = 4, outerSpacing = 5;
          Dimension size = parent.getSize();
          int gapsAndMargins = outerSpacing * 2 - (l(l) - 1) * gap;
          int totalSpace = size.height - gapsAndMargins - fixer2;
          int liberalSpace = totalSpace - mandatoryHeight;
          double perBigOne = doubleRatio(liberalSpace, nBigOnes);
          double y = outerSpacing;
          for (int i = 0; i < l(l); i++) {
            Component c = l.get(i);
            boolean big = contains(bigOnes, i);
            double h = big ? perBigOne : c.getPreferredSize().height;
            int actualY = iround(y);
            c.setBounds(10, actualY, size.width - outerSpacing * 2, iround(y + h) - actualY);
            y += h + gap;
          }
          Dimension pref = componentsBoundingSize(parent, outerSpacing);
          if (parent.getHeight() <= 0) {
            int tph = totalPreferredHeight(l);
            pref.height = tph + gapsAndMargins + yplus;
          }
          return pref;
        } catch (Exception __e) {
          throw rethrow(__e);
        }
      }

      public String toString() {
        return "L<Component> l = getComponents(parent);\r\n    new BitSet bigOnes;\r\n    for i o...";
      }
    };
  }

  static public double toM_double(long l) {
    return l / (1024 * 1024.0);
  }

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

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

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

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

  static public ArrayList<Integer> toList(int[] a) {
    return asList(a);
  }

  static public <A> ArrayList<A> toList(Set<A> s) {
    return asList(s);
  }

  static public <A> ArrayList<A> toList(Iterable<A> s) {
    return asList(s);
  }

  static public <A extends JTextComponent> A setTextKeepCaret(final String text, final A c) {
    if (c != null) {
      swing(() -> {
        int caret = c.getCaretPosition();
        setText(c, text);
        setCaretPosition(c, caret);
      });
    }
    return c;
  }

  static public <A extends JTextComponent> A setTextKeepCaret(A c, String text) {
    return setTextKeepCaret(text, c);
  }

  static public AutoCloseable tempAddConceptIndex(IConceptIndex index) {
    return tempAddConceptIndex(db_mainConcepts(), index);
  }

  static public AutoCloseable tempAddConceptIndex(Concepts cc, IConceptIndex index) {
    cc.addConceptIndex(index);
    return () -> cc.removeConceptIndex(index);
  }

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

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

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

  static public Point getMouseLocation() {
    return MouseInfo.getPointerInfo().getLocation();
  }

  static public int indexOfPred(List l, Object pred) {
    for (int i = 0; i < l(l); i++) if (checkCondition(pred, l.get(i)))
      return i;
    return -1;
  }

  static public <A, B> int indexOfPred(List<A> l, IF1<A, B> pred) {
    return indexOfPred(l, (Object) pred);
  }

  static public Iterator emptyIterator() {
    return Collections.emptyIterator();
  }

  static public BufferedImage intArrayToBufferedImage(int[] pixels, int w, int h) {
    int[] bitMasks = new int[] { 0xFF0000, 0xFF00, 0xFF, 0xFF000000 };
    SinglePixelPackedSampleModel sm = new SinglePixelPackedSampleModel(DataBuffer.TYPE_INT, w, h, bitMasks);
    DataBufferInt db = new DataBufferInt(pixels, pixels.length);
    WritableRaster wr = Raster.createWritableRaster(sm, db, new Point());
    return new BufferedImage(ColorModel.getRGBdefault(), wr, false, null);
  }

  static public Random customRandomizerForThisThread() {
    return customRandomizerForThisThread_tl().get();
  }

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

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

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

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

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

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

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

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

      public void close() {
        listThreadLocalPopLast(holdInstance_l);
      }
    };
  }

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

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

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

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

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

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

  static public String joinStrings(String sep, Object... strings) {
    return joinStrings(sep, Arrays.asList(strings));
  }

  static public String joinStrings(String sep, Iterable strings) {
    StringBuilder buf = new StringBuilder();
    for (Object o : unnull(strings)) {
      String s = strOrNull(o);
      if (nempty(s)) {
        if (nempty(buf))
          buf.append(sep);
        buf.append(s);
      }
    }
    return str(buf);
  }

  static public <A, B> Comparator<A> mapComparator(final Map<A, B> map) {
    return new Comparator<A>() {

      public int compare(A a, A b) {
        return cmp(map.get(a), map.get(b));
      }
    };
  }

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

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

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

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

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

  static public java.awt.Color awtColor(String hex) {
    byte[] b = bytesFromHex(dropPrefix("#", hex));
    return new Color(ubyteToInt(b[0]), ubyteToInt(b[1]), ubyteToInt(b[2]));
  }

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

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

  static public File userDir_oneOf(String... names) {
    return oneOfTheFilesInDir(userDir(), names);
  }

  static public File userDir() {
    return new File(userHome());
  }

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

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

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

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

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

  static volatile public boolean licensed_yes = true;

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

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

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

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

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

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

  static public void lockOrFail(Lock lock, long timeout) {
    try {
      ping();
      vmBus_send("locking", lock, "thread", currentThread());
      if (!lock.tryLock(timeout, TimeUnit.MILLISECONDS)) {
        String s = "Couldn't acquire lock after " + timeout + " ms.";
        if (lock instanceof ReentrantLock) {
          ReentrantLock l = (ReentrantLock) lock;
          s += " Hold count: " + l.getHoldCount() + ", owner: " + call(l, "getOwner");
        }
        throw fail(s);
      }
      vmBus_send("locked", lock, "thread", currentThread());
      ping();
    } catch (Exception __e) {
      throw rethrow(__e);
    }
  }

  static public ReentrantLock fairLock() {
    return new ReentrantLock(true);
  }

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

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

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

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

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

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

  static public boolean isEmpty(DoubleRange r) {
    return r == null || r.isEmpty();
  }

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

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

  static public int menuItemCount(JMenu menu) {
    return menu == null ? 0 : swing(() -> menu.getItemCount());
  }

  static public <A extends Component> A revalidate(final A c) {
    if (c == null || !c.isShowing())
      return c;
    {
      swing(() -> {
        c.revalidate();
        c.repaint();
      });
    }
    return c;
  }

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

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

  static public JPanel jpanel(LayoutManager layout) {
    return swingNu(JPanel.class, layout);
  }

  static public JPanel jpanel() {
    return swingNu(JPanel.class);
  }

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

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

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

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

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

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

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

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

  static public CloseableIterableIterator emptyCloseableIterableIterator_instance = new CloseableIterableIterator() {

    public Object next() {
      throw fail();
    }

    public boolean hasNext() {
      return false;
    }
  };

  static public <A> CloseableIterableIterator<A> emptyCloseableIterableIterator() {
    return emptyCloseableIterableIterator_instance;
  }

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

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

  static public CloseableIterableIterator<String> linesFromReader(Reader r) {
    return linesFromReader(r, null);
  }

  static public CloseableIterableIterator<String> linesFromReader(Reader r, IResourceHolder resourceHolder) {
    final BufferedReader br = bufferedReader(r);
    return holdResource(resourceHolder, iteratorFromFunction_f0_autoCloseable(new F0<String>() {

      public String get() {
        try {
          return readLineFromReaderWithClose(br);
        } catch (Exception __e) {
          throw rethrow(__e);
        }
      }

      public String toString() {
        return "return readLineFromReaderWithClose(br);";
      }
    }, _wrapIOCloseable(r)));
  }

  static public BufferedReader utf8bufferedReader(InputStream in) {
    try {
      return in == null ? null : bufferedReader(_registerIOWrap(new InputStreamReader(in, "UTF-8"), in));
    } catch (Exception __e) {
      throw rethrow(__e);
    }
  }

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

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

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

  static public String fsI(String id) {
    return formatSnippetID(id);
  }

  static public String fsI(long id) {
    return formatSnippetID(id);
  }

  static public File loadBinarySnippet(String snippetID) {
    IResourceLoader rl = vm_getResourceLoader();
    if (rl != null)
      return rl.loadLibrary(snippetID);
    return loadBinarySnippet_noResourceLoader(snippetID);
  }

  static public File loadBinarySnippet_noResourceLoader(String snippetID) {
    try {
      long id = parseSnippetID(snippetID);
      if (isImageServerSnippet(id))
        return loadImageAsFile(snippetID);
      File f = DiskSnippetCache_getLibrary(id);
      if (fileSize(f) == 0)
        f = loadDataSnippetToFile_noResourceLoader(snippetID);
      return f;
    } catch (Exception __e) {
      throw rethrow(__e);
    }
  }

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

  static public boolean loadBufferedImageFixingGIFs_debug = false;

  static public ThreadLocal<Var<byte[]>> loadBufferedImageFixingGIFs_output = new ThreadLocal();

  static public Image loadBufferedImageFixingGIFs(File file) {
    try {
      if (!file.exists())
        return null;
      if (!isGIF(file))
        return ImageIO.read(file);
      if (loadBufferedImageFixingGIFs_debug)
        print("loadBufferedImageFixingGIFs" + ": checking gif");
      ImageReader reader = ImageIO.getImageReadersByFormatName("gif").next();
      reader.setInput(ImageIO.createImageInputStream(file));
      int numImages = reader.getNumImages(true);
      IIOMetadata imageMetaData = reader.getImageMetadata(0);
      String metaFormatName = imageMetaData.getNativeMetadataFormatName();
      boolean foundBug = false;
      for (int i = 0; i < numImages && !foundBug; i++) {
        IIOMetadataNode root = (IIOMetadataNode) reader.getImageMetadata(i).getAsTree(metaFormatName);
        int nNodes = root.getLength();
        for (int j = 0; j < nNodes; j++) {
          org.w3c.dom.Node node = root.item(j);
          if (node.getNodeName().equalsIgnoreCase("GraphicControlExtension")) {
            String delay = ((IIOMetadataNode) node).getAttribute("delayTime");
            if (Integer.parseInt(delay) == 0) {
              foundBug = true;
            }
            break;
          }
        }
      }
      if (loadBufferedImageFixingGIFs_debug)
        print("loadBufferedImageFixingGIFs" + ": " + f2s(file) + " foundBug=" + foundBug);
      Image image;
      if (!foundBug) {
        image = Toolkit.getDefaultToolkit().createImage(f2s(file));
      } else {
        ByteArrayOutputStream baoStream = new ByteArrayOutputStream();
        {
          ImageOutputStream ios = ImageIO.createImageOutputStream(baoStream);
          try {
            ImageWriter writer = ImageIO.getImageWriter(reader);
            writer.setOutput(ios);
            writer.prepareWriteSequence(null);
            for (int i = 0; i < numImages; i++) {
              BufferedImage frameIn = reader.read(i);
              IIOMetadataNode root = (IIOMetadataNode) reader.getImageMetadata(i).getAsTree(metaFormatName);
              int nNodes = root.getLength();
              for (int j = 0; j < nNodes; j++) {
                org.w3c.dom.Node node = root.item(j);
                if (node.getNodeName().equalsIgnoreCase("GraphicControlExtension")) {
                  String delay = ((IIOMetadataNode) node).getAttribute("delayTime");
                  if (Integer.parseInt(delay) == 0) {
                    ((IIOMetadataNode) node).setAttribute("delayTime", "10");
                  }
                  break;
                }
              }
              IIOMetadata metadata = writer.getDefaultImageMetadata(new ImageTypeSpecifier(frameIn), null);
              metadata.setFromTree(metadata.getNativeMetadataFormatName(), root);
              IIOImage frameOut = new IIOImage(frameIn, null, metadata);
              writer.writeToSequence(frameOut, writer.getDefaultWriteParam());
            }
            writer.endWriteSequence();
          } finally {
            _close(ios);
          }
        }
        byte[] data = baoStream.toByteArray();
        setVar(loadBufferedImageFixingGIFs_output.get(), data);
        if (loadBufferedImageFixingGIFs_debug)
          print("Data size: " + l(data));
        image = Toolkit.getDefaultToolkit().createImage(data);
      }
      return image;
    } catch (Exception __e) {
      throw rethrow(__e);
    }
  }

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

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

  public static File mkdirsFor(File file) {
    return mkdirsForFile(file);
  }

  static public BufferedImage reconstructBufferedImage(BufferedImage img) {
    if (img == null)
      return null;
    RGBImage rgb = new RGBImage(img);
    rgb.uncacheBufferedImage();
    return rgb.getBufferedImage();
  }

  static public List<CriticalAction> beginCriticalAction_inFlight = synchroList();

  static public class CriticalAction {

    public String description;

    public CriticalAction() {
    }

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

    public void done() {
      beginCriticalAction_inFlight.remove(this);
    }
  }

  static public CriticalAction beginCriticalAction(String description) {
    ping();
    CriticalAction c = new CriticalAction(description);
    beginCriticalAction_inFlight.add(c);
    return c;
  }

  static public void cleanMeUp_beginCriticalAction() {
    int n = 0;
    while (nempty(beginCriticalAction_inFlight)) {
      int m = l(beginCriticalAction_inFlight);
      if (m != n) {
        n = m;
        try {
          print("Waiting for " + n2(n, "critical actions") + ": " + join(", ", collect(beginCriticalAction_inFlight, "description")));
        } catch (Throwable __e) {
          printStackTrace(__e);
        }
      }
      sleepInCleanUp(10);
    }
  }

  static public AutoCloseable tempLock(Lock lock) {
    return tempLock("", lock);
  }

  static public AutoCloseable tempLock(String purpose, Lock lock) {
    if (lock == null)
      return null;
    lock(lock);
    return new AutoCloseable() {

      public String toString() {
        return "unlock(lock);";
      }

      public void close() throws Exception {
        unlock(lock);
      }
    };
  }

  static public String singleFieldName(Class c) {
    Set<String> l = listFields(c);
    if (l(l) != 1)
      throw fail("No single field found in " + c + " (have " + n(l(l), "fields") + ")");
    return first(l);
  }

  static public Object nuObject(String className, Object... args) {
    try {
      return nuObject(classForName(className), args);
    } catch (Exception __e) {
      throw rethrow(__e);
    }
  }

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

  static public Constructor nuObject_findConstructor(Class c, Object... args) {
    for (Constructor m : c.getDeclaredConstructors()) {
      if (!nuObject_checkArgs(m.getParameterTypes(), args, false))
        continue;
      return m;
    }
    throw fail("Constructor " + c.getName() + getClasses(args) + " not found" + (args.length == 0 && (c.getModifiers() & java.lang.reflect.Modifier.STATIC) == 0 ? " - hint: it's a non-static class!" : ""));
  }

  static public boolean nuObject_checkArgs(Class[] types, Object[] args, boolean debug) {
    if (types.length != args.length) {
      if (debug)
        System.out.println("Bad parameter length: " + args.length + " vs " + types.length);
      return false;
    }
    for (int i = 0; i < types.length; i++) if (!(args[i] == null || isInstanceX(types[i], args[i]))) {
      if (debug)
        System.out.println("Bad parameter " + i + ": " + args[i] + " vs " + types[i]);
      return false;
    }
    return true;
  }

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

  static public <A> A proxy(Class<A> intrface, final Object target) {
    if (target == null)
      return null;
    if (isInstance(intrface, target))
      return (A) target;
    return (A) java.lang.reflect.Proxy.newProxyInstance(intrface.getClassLoader(), new Class[] { intrface }, new proxy_InvocationHandler(target));
  }

  static public <A> A proxy(Object target, Class<A> intrface) {
    return proxy(intrface, target);
  }

  static public File javaxCachesDir_dir;

  static public File javaxCachesDir() {
    return javaxCachesDir_dir != null ? javaxCachesDir_dir : new File(userHome(), "JavaX-Caches");
  }

  static public File javaxCachesDir(String sub) {
    return newFile(javaxCachesDir(), sub);
  }

  static public String snippetImageURL(long snippetID) {
    return snippetImageURL(fsI(snippetID));
  }

  static public String snippetImageURL(String snippetID) {
    return snippetImageURL(snippetID, "png");
  }

  static public String snippetImageURL(String snippetID, String contentType) {
    if (snippetID == null || isURL(snippetID))
      return snippetID;
    long id = parseSnippetID(snippetID);
    String url;
    if (isImageServerSnippet(id))
      url = imageServerLink(id);
    else
      url = "https://botcompany.de/img/" + id;
    return url;
  }

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

  static public void assertFalse(Object o) {
    if (!(eq(o, false)))
      throw fail(str(o));
  }

  static public boolean assertFalse(boolean b) {
    if (b)
      throw fail("oops");
    return b;
  }

  static public boolean assertFalse(String msg, boolean b) {
    if (b)
      throw fail(msg);
    return b;
  }

  static public boolean containsNulls(Collection c) {
    return contains(c, null);
  }

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

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

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

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

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

  static public <A> A[] arrayOfType(Class<A> type, int n) {
    return makeArray(type, n);
  }

  static public <A> A[] arrayOfType(int n, Class<A> type) {
    return arrayOfType(type, n);
  }

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

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

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

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

  static public JPanel makeForm_customArrangement(F1<List<JComponent>, JPanel> arrange, final Object... _parts) {
    return makeForm_customArrangement(null, arrange, _parts);
  }

  static public JPanel makeForm_customArrangement(Boolean internalFrame, F1<List<JComponent>, JPanel> arrange, final Object... _parts) {
    return swing(new F0<JPanel>() {

      public JPanel get() {
        try {
          return callF(arrange, showForm_arrange1(showForm_makeComponents(internalFrame, _parts)));
        } catch (Exception __e) {
          throw rethrow(__e);
        }
      }

      public String toString() {
        return "return callF(arrange,\r\n      showForm_arrange1(showForm_makeComponents(intern...";
      }
    });
  }

  static public JPanel customLayoutPanel(final Object layouter) {
    return jpanel(layoutManagerFromFunction(layouter));
  }

  static public JPanel customLayoutPanel(final Object layouter, final List<? extends Component> components) {
    return addAllComponents(customLayoutPanel(layouter), components);
  }

  static public boolean containsATextArea(Component c) {
    return childOfType(c, JTextArea.class) != null;
  }

  static public int totalPreferredHeight(List<Component> l) {
    int h = 0;
    for (Component c : unnull(l)) h += c.getPreferredSize().height;
    return h;
  }

  static public <A> List<A> listWithoutIndicesInBitSet(List<A> l, BitSet bs) {
    List<A> out = new ArrayList();
    for (int i = 0; i < l(l); i++) if (!bs.get(i))
      out.add(l.get(i));
    return out;
  }

  static public Dimension componentsBoundingSize(Container container, int insetBottomRight) {
    Rectangle r = new Rectangle(0, 0, 0, 0);
    for (Component c : container.getComponents()) r = rectangleUnion(r, c.getBounds());
    return new Dimension(r.x + r.width + insetBottomRight, r.y + r.height + insetBottomRight);
  }

  static public String classNameToVM(String name) {
    return name.replace(".", "$");
  }

  static public void setCaretPosition(final JTextComponent c, final int pos) {
    if (c != null) {
      swing(() -> {
        try {
          int _pos = max(0, min(l(c.getText()), pos));
          c.setCaretPosition(_pos);
        } catch (Throwable __e) {
          printStackTrace(__e);
        }
      });
    }
  }

  static public ThreadLocal<Random> customRandomizerForThisThread_tl = new ThreadLocal();

  static public ThreadLocal<Random> customRandomizerForThisThread_tl() {
    return customRandomizerForThisThread_tl;
  }

  static public String defaultThreadName_name;

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

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

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

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

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

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

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

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

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

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

  static public Map<Thread, Boolean> _registerThread_threads;

  static public Object _onRegisterThread;

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

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

  static public <A> void listThreadLocalAdd(ThreadLocal<List<A>> tl, A a) {
    List<A> l = tl.get();
    if (l == null)
      tl.set(l = new ArrayList());
    l.add(a);
  }

  static public <A> A listThreadLocalPopLast(ThreadLocal<List<A>> tl) {
    List<A> l = tl.get();
    if (l == null)
      return null;
    A a = popLast(l);
    if (empty(l))
      tl.set(null);
    return a;
  }

  static public boolean headless() {
    return isHeadless();
  }

  static public Throwable innerException2(Throwable e) {
    if (e == null)
      return null;
    while (empty(e.getMessage()) && e.getCause() != null) e = e.getCause();
    return e;
  }

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

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

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

  static public int ubyteToInt(byte b) {
    return b & 0x0FF;
  }

  static public int ubyteToInt(char c) {
    return c & 0x0FF;
  }

  static public File oneOfTheFilesInDir(File dir, String... names) {
    return oneOfTheFiles(map(names, name -> newFile(dir, name)));
  }

  static public String _userHome;

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

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

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

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

  static public <A> int lastIndexOf(List<A> l, int i, A a) {
    if (l == null)
      return -1;
    for (i = min(l(l), i) - 1; i >= 0; i--) if (eq(l.get(i), a))
      return i;
    return -1;
  }

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

  static public Set vm_busListeners_live_cache;

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

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

  static public Map<String, Set> vm_busListenersByMessage_live_cache;

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

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

  static public Map vm_generalMap_map;

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

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

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

  static public BufferedReader bufferedReader(Reader r) {
    return bufferedReader(r, 8192);
  }

  static public BufferedReader bufferedReader(Reader r, int bufSize) {
    if (r == null)
      return null;
    return r instanceof BufferedReader ? (BufferedReader) r : _registerIOWrap(new BufferedReader(r, bufSize), r);
  }

  static public <A extends AutoCloseable> A holdResource(IResourceHolder holder, A a) {
    {
      if (holder != null)
        holder.add(a);
    }
    return a;
  }

  static public <A> CloseableIterableIterator<A> iteratorFromFunction_f0_autoCloseable(final F0<A> f, final AutoCloseable closeable) {
    class IFF2 extends CloseableIterableIterator<A> {

      public A a;

      public boolean done = false;

      public boolean hasNext() {
        getNext();
        return !done;
      }

      public A next() {
        getNext();
        if (done)
          throw fail();
        A _a = a;
        a = null;
        return _a;
      }

      public void getNext() {
        if (done || a != null)
          return;
        a = f.get();
        done = a == null;
      }

      public void close() throws Exception {
        if (closeable != null)
          closeable.close();
      }
    }
    ;
    return new IFF2();
  }

  static public String readLineFromReaderWithClose(BufferedReader r) {
    try {
      String s = r.readLine();
      if (s == null)
        r.close();
      return s;
    } catch (Exception __e) {
      throw rethrow(__e);
    }
  }

  static public AutoCloseable _wrapIOCloseable(final AutoCloseable c) {
    return c == null ? null : new AutoCloseable() {

      public String toString() {
        return "c.close();\r\n    _registerIO(c, null, false);";
      }

      public void close() throws Exception {
        c.close();
        _registerIO(c, null, false);
      }
    };
  }

  static public <A> A _registerIOWrap(A wrapper, Object wrapped) {
    return wrapper;
  }

  static public FileInputStream newFileInputStream(File path) throws IOException {
    return newFileInputStream(path.getPath());
  }

  static public FileInputStream newFileInputStream(String path) throws IOException {
    FileInputStream f = new FileInputStream(path);
    _registerIO(f, path, true);
    return f;
  }

  static public int gzInputStream_defaultBufferSize = 65536;

  static public GZIPInputStream gzInputStream(File f) {
    try {
      return gzInputStream(new FileInputStream(f));
    } catch (Exception __e) {
      throw rethrow(__e);
    }
  }

  static public GZIPInputStream gzInputStream(File f, int bufferSize) {
    try {
      return gzInputStream(new FileInputStream(f), bufferSize);
    } catch (Exception __e) {
      throw rethrow(__e);
    }
  }

  static public GZIPInputStream gzInputStream(InputStream in) {
    return gzInputStream(in, gzInputStream_defaultBufferSize);
  }

  static public GZIPInputStream gzInputStream(InputStream in, int bufferSize) {
    try {
      return _registerIOWrap(new GZIPInputStream(in, gzInputStream_defaultBufferSize), in);
    } catch (Exception __e) {
      throw rethrow(__e);
    }
  }

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

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

  static public boolean isImageServerSnippet(long id) {
    return id >= 1100000 && id < 1200000;
  }

  static public File loadImageAsFile(String snippetIDOrURL) {
    try {
      if (isURL(snippetIDOrURL))
        throw fail("not implemented");
      if (!isSnippetID(snippetIDOrURL))
        throw fail("Not a URL or snippet ID: " + snippetIDOrURL);
      String snippetID = "" + parseSnippetID(snippetIDOrURL);
      File file = imageSnippetCacheFile(snippetID);
      if (fileSize(file) > 0)
        return file;
      String imageURL = snippetImageURL_noHttps(snippetID);
      System.err.println("Loading image: " + imageURL);
      byte[] data = loadBinaryPage(imageURL);
      saveBinaryFile(file, data);
      return file;
    } catch (Exception __e) {
      throw rethrow(__e);
    }
  }

  static public File DiskSnippetCache_file(long snippetID) {
    return new File(getGlobalCache(), "data_" + snippetID + ".jar");
  }

  public static File DiskSnippetCache_getLibrary(long snippetID) throws IOException {
    File file = DiskSnippetCache_file(snippetID);
    return file.exists() ? file : null;
  }

  public static void DiskSnippetCache_putLibrary(long snippetID, byte[] data) throws IOException {
    saveBinaryFile(DiskSnippetCache_file(snippetID), data);
  }

  static public byte[] loadDataSnippetImpl(String snippetID) throws IOException {
    byte[] data;
    try {
      URL url = new URL(dataSnippetLink(snippetID));
      print("Loading library: " + hideCredentials(url));
      try {
        data = loadBinaryPage(url.openConnection());
      } catch (RuntimeException e) {
        data = null;
      }
      if (data == null || data.length == 0) {
        url = new URL(tb_mainServer() + "/blobs/" + parseSnippetID(snippetID));
        print("Loading library: " + hideCredentials(url));
        data = loadBinaryPage(url.openConnection());
      }
      print("Bytes loaded: " + data.length);
    } catch (FileNotFoundException e) {
      throw new IOException("Binary snippet #" + snippetID + " not found or not public");
    }
    return data;
  }

  static public File loadDataSnippetToFile(String snippetID) {
    try {
      IResourceLoader rl = vm_getResourceLoader();
      if (rl != null)
        return rl.loadLibrary(snippetID);
      return loadDataSnippetToFile_noResourceLoader(snippetID);
    } catch (Exception __e) {
      throw rethrow(__e);
    }
  }

  static public File loadDataSnippetToFile_noResourceLoader(String snippetID) {
    try {
      snippetID = fsI(snippetID);
      File f = DiskSnippetCache_file(parseSnippetID(snippetID));
      List<URL> urlsTried = new ArrayList();
      List<Throwable> errors = new ArrayList();
      try {
        URL url = addAndReturn(urlsTried, new URL(dataSnippetLink(snippetID)));
        print("Loading library: " + hideCredentials(url));
        try {
          loadBinaryPageToFile(openConnection(url), f);
          if (fileSize(f) == 0)
            throw fail();
        } catch (Throwable e) {
          errors.add(e);
          url = addAndReturn(urlsTried, new URL(tb_mainServer() + "/blobs/" + psI(snippetID)));
          print(e);
          print("Trying other server: " + hideCredentials(url));
          loadBinaryPageToFile(openConnection(url), f);
          print("Got bytes: " + fileSize(f));
        }
        if (fileSize(f) == 0)
          throw fail();
        System.err.println("Bytes loaded: " + fileSize(f));
      } catch (Throwable e) {
        errors.add(e);
        throw fail("Binary snippet " + snippetID + " not found or not public. URLs tried: " + allToString(urlsTried) + ", errors: " + allToString(errors));
      }
      return f;
    } catch (Exception __e) {
      throw rethrow(__e);
    }
  }

  static public byte[] isGIF_magic = bytesFromHex("47494638");

  static public boolean isGIF(byte[] data) {
    return byteArrayStartsWith(data, isGIF_magic);
  }

  static public boolean isGIF(File f) {
    return isGIF(loadBeginningOfBinaryFile(f, l(isGIF_magic)));
  }

  static public <A> void setVar(IVar<A> v, A value) {
    if (v != null)
      v.set(value);
  }

  static public <A> IVF1<A> setVar(IVar<A> v) {
    return a -> {
      if (v != null)
        v.set(a);
    };
  }

  public static File mkdirsForFile(File file) {
    File dir = file.getParentFile();
    if (dir != null) {
      dir.mkdirs();
      if (!dir.isDirectory())
        if (dir.isFile())
          throw fail("Please delete the file " + f2s(dir) + " - it is supposed to be a directory!");
        else
          throw fail("Unknown IO exception during mkdirs of " + f2s(file));
    }
    return file;
  }

  public static String mkdirsForFile(String path) {
    mkdirsForFile(new File(path));
    return path;
  }

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

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

  static public List collect(Iterable c, String field) {
    return collectField(c, field);
  }

  static public List collect(String field, Iterable c) {
    return collectField(c, field);
  }

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

  static public Set<String> listFields(Object c) {
    TreeSet<String> fields = new TreeSet();
    for (Field f : _getClass(c).getDeclaredFields()) fields.add(f.getName());
    return fields;
  }

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

  static public Class classForName(String name) {
    return classForName(name, null);
  }

  static public Class classForName(String name, Object classFinder) {
    if (classForName_cache == null || classFinder != null)
      return classForName_uncached(name, classFinder);
    Class c = classForName_cache.get(name);
    if (c == null)
      classForName_cache.put(name, c = classForName_uncached(name, null));
    return c;
  }

  static public Class classForName_uncached(String name, Object classFinder) {
    try {
      if (classFinder != null)
        return (Class) callF(classFinder, name);
      return Class.forName(name);
    } catch (Exception __e) {
      throw rethrow(__e);
    }
  }

  static public Map<Class, Constructor> nuObjectWithoutArguments_cache = newDangerousWeakHashMap();

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

  static public <A> A nuObjectWithoutArguments(Class<A> c) {
    try {
      if (nuObjectWithoutArguments_cache == null)
        return (A) nuObjectWithoutArguments_findConstructor(c).newInstance();
      Constructor m = nuObjectWithoutArguments_cache.get(c);
      if (m == null)
        nuObjectWithoutArguments_cache.put(c, m = nuObjectWithoutArguments_findConstructor(c));
      return (A) m.newInstance();
    } catch (Exception __e) {
      throw rethrow(__e);
    }
  }

  static public Constructor nuObjectWithoutArguments_findConstructor(Class c) {
    for (Constructor m : c.getDeclaredConstructors()) if (empty(m.getParameterTypes())) {
      makeAccessible(m);
      return m;
    }
    throw fail("No default constructor found in " + c.getName());
  }

  static public Field makeAccessible(Field f) {
    try {
      f.setAccessible(true);
    } catch (Throwable e) {
      vmBus_send("makeAccessible_error", e, f);
    }
    return f;
  }

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

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

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

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

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

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

  static public String imageServerLink(String md5OrID) {
    if (possibleMD5(md5OrID))
      return "https://botcompany.de/images/md5/" + md5OrID;
    return imageServerLink(parseSnippetID(md5OrID));
  }

  static public String imageServerLink(long id) {
    return "https://botcompany.de/images/" + id;
  }

  static public <A> A[] makeArray(Class<A> type, int n) {
    return (A[]) Array.newInstance(type, n);
  }

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

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

  static public List<JComponent> showForm_arrange1(List<List<JComponent>> l) {
    int minW = showForm_leftWidth(l);
    List<JComponent> out = new ArrayList();
    for (List<JComponent> row : l) out.add(westAndCenter(withRightMargin(showForm_gapBetweenColumns, jMinWidthAtLeast(minW, first(row))), second(row)));
    return out;
  }

  static public List<List<JComponent>> showForm_makeComponents(final Boolean internalFrame, Object... _parts) {
    List<List<JComponent>> l = new ArrayList();
    List parts = asList(_parts);
    JButton submitButton = null;
    for (int i = 0; i < l(parts); i++) {
      final Object o = parts.get(i), next = get(parts, i + 1);
      if (o instanceof String && next instanceof Component)
        setComponentID((Component) next, (String) o);
      if (o instanceof Component || o instanceof String || next instanceof Component) {
        l.add(mapLL(__44 -> wrapForSmartAdd_jComponent(__44), o == null ? new JPanel() : o instanceof String ? humanizeFormLabel((String) o) : o, next));
        if (next instanceof JButton && submitButton == null)
          submitButton = (JButton) next;
        i++;
      } else if (isRunnable(o))
        l.add(mapLL(__45 -> wrapForSmartAdd_jComponent(__45), null, submitButton = jbutton(showFormSubmitButtonName(), new Runnable() {

          public void run() {
            try {
              Object result = call(o);
              print("Result of form runnable: " + result + ". Button:  " + heldInstance(JButton.class));
              if (neq(Boolean.FALSE, result)) {
                if (isTrue(internalFrame))
                  disposeInternalFrame(heldInstance(JButton.class));
                else if (isFalse(internalFrame))
                  disposeFrame(heldInstance(JButton.class));
              }
            } catch (Exception __e) {
              throw rethrow(__e);
            }
          }

          public String toString() {
            return "Object result = call(o);\r\n        print(\"Result of form runnable: \" + result ...";
          }
        })));
      else
        print("showForm: Unknown element type: " + getClassName(o));
    }
    if (submitButton != null) {
      final JButton _submitButton = submitButton;
      onEnterInAllTextFields(concatLists(l), new Runnable() {

        public void run() {
          try {
            clickButton(_submitButton);
          } catch (Exception __e) {
            throw rethrow(__e);
          }
        }

        public String toString() {
          return "clickButton(_submitButton)";
        }
      });
    }
    for (List<JComponent> row : l) {
      JComponent left = first(row);
      if (left instanceof JLabel)
        makeBold((JLabel) left).setVerticalAlignment(JLabel.TOP);
    }
    return l;
  }

  static public LayoutManager layoutManagerFromFunction(final Object layouter) {
    return new AbstractLayoutManager() {

      public void layoutContainer(Container parent) {
        Object size = pcallF(layouter, parent);
        if (size instanceof Dimension)
          preferredSize = (Dimension) size;
        else if (size instanceof Pair) {
          preferredSize = (Dimension) ((Pair) size).a;
          minimumSize = (Dimension) ((Pair) size).b;
        }
      }
    };
  }

  static public <A extends Container> A addAllComponents(final A c, final List<? extends Component> components) {
    if (nempty(components)) {
      swing(() -> {
        for (Component x : components) c.add(x);
        revalidate(c);
      });
    }
    return c;
  }

  static public Rectangle rectangleUnion(Rectangle a, Rectangle b) {
    return a == null ? b : b == null ? a : a.union(b);
  }

  static public int showForm_defaultGap = 4;

  static public int showForm_gapBetweenColumns = 10;

  static public JPanel showFormTitled(final String title, final Object... _parts) {
    JDesktopPane desktop = mainDesktopPane();
    if (desktop != null)
      return showInternalFrameFormTitled(desktop, title, _parts);
    return swing(new F0<JPanel>() {

      public JPanel get() {
        try {
          final Var<JFrame> frame = new Var();
          JPanel panel = showForm_makePanel(false, _parts);
          showForm_makeFrame(title, panel);
          frame.set(getFrame(panel));
          return panel;
        } catch (Exception __e) {
          throw rethrow(__e);
        }
      }

      public String toString() {
        return "final new Var<JFrame> frame;\r\n    JPanel panel = showForm_makePanel(false, _p...";
      }
    });
  }

  static public JPanel showForm_makePanel(Boolean internalFrame, Object... _parts) {
    List<JComponent> out = showForm_arrange1(showForm_makeComponents(internalFrame, _parts));
    return vstackWithSpacing(out, showForm_defaultGap);
  }

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

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

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

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

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

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

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

  static public <A> A popLast(List<A> l) {
    return liftLast(l);
  }

  static public <A> List<A> popLast(int n, List<A> l) {
    return liftLast(n, l);
  }

  static public byte[] hexToBytes(String s) {
    if (odd(l(s)))
      throw fail("Hex string has odd length: " + quote(shorten(10, s)));
    int n = l(s) / 2;
    byte[] bytes = new byte[n];
    for (int i = 0; i < n; i++) {
      int a = parseHexChar(s.charAt(i * 2));
      int b = parseHexChar(s.charAt(i * 2 + 1));
      if (a < 0 || b < 0)
        throw fail("Bad hex byte: " + quote(substring(s, i * 2, i * 2 + 2)) + " at " + i * 2 + "/" + l(s));
      bytes[i] = (byte) ((a << 4) | b);
    }
    return bytes;
  }

  static public File oneOfTheFiles(String... paths) {
    if (paths != null)
      for (String path : paths) if (fileExists(path))
        return newFile(path);
    return null;
  }

  static public File oneOfTheFiles(File... files) {
    return oneOfTheFiles(asList(files));
  }

  static public File oneOfTheFiles(Iterable<File> files) {
    if (files != null)
      for (File f : files) if (fileExists(f))
        return f;
    return null;
  }

  static public String actualUserHome_value;

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

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

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

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

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

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

  static public void _registerIO(Object object, String path, boolean opened) {
  }

  static public File imageSnippetCacheFile(String snippetID) {
    File dir = imageSnippetsCacheDir();
    if (!loadBufferedImage_useImageCache)
      return null;
    return new File(dir, parseSnippetID(snippetID) + ".png");
  }

  static public String snippetImageURL_noHttps(String snippetID) {
    return snippetImageURL_noHttps(snippetID, "png");
  }

  static public String snippetImageURL_noHttps(String snippetID, String contentType) {
    return snippetImageURL(snippetID, contentType).replace("https://www.botcompany.de:8443/", "http://www.botcompany.de:8080/").replace("https://botcompany.de/", "http://botcompany.de/");
  }

  static public ThreadLocal<Map<String, List<String>>> loadBinaryPage_responseHeaders = new ThreadLocal();

  static public ThreadLocal<Map<String, String>> loadBinaryPage_extraHeaders = new ThreadLocal();

  static public byte[] loadBinaryPage(String url) {
    try {
      print("Loading " + url);
      return loadBinaryPage(loadPage_openConnection(new URL(url)));
    } catch (Exception __e) {
      throw rethrow(__e);
    }
  }

  static public byte[] loadBinaryPage(URLConnection con) {
    try {
      Map<String, String> extraHeaders = getAndClearThreadLocal(loadBinaryPage_extraHeaders);
      setHeaders(con);
      for (String key : keys(extraHeaders)) con.setRequestProperty(key, extraHeaders.get(key));
      return loadBinaryPage_noHeaders(con);
    } catch (Exception __e) {
      throw rethrow(__e);
    }
  }

  static public byte[] loadBinaryPage_noHeaders(URLConnection con) {
    try {
      ByteArrayOutputStream buf = new ByteArrayOutputStream();
      InputStream inputStream = con.getInputStream();
      loadBinaryPage_responseHeaders.set(con.getHeaderFields());
      long len = 0;
      try {
        len = con.getContentLength();
      } catch (Throwable e) {
        printStackTrace(e);
      }
      int n = 0;
      while (true) {
        int ch = inputStream.read();
        if (ch < 0)
          break;
        buf.write(ch);
        if (++n % 100000 == 0)
          println("  " + n + (len != 0 ? "/" + len : "") + " bytes loaded.");
      }
      inputStream.close();
      return buf.toByteArray();
    } catch (Exception __e) {
      throw rethrow(__e);
    }
  }

  public static byte[] saveBinaryFile(String fileName, byte[] contents) {
    try {
      File file = new File(fileName);
      File parentFile = file.getParentFile();
      if (parentFile != null)
        parentFile.mkdirs();
      String tempFileName = fileName + "_temp";
      FileOutputStream fileOutputStream = newFileOutputStream(tempFileName);
      fileOutputStream.write(contents);
      fileOutputStream.close();
      if (file.exists() && !file.delete())
        throw new IOException("Can't delete " + fileName);
      if (!new File(tempFileName).renameTo(file))
        throw new IOException("Can't rename " + tempFileName + " to " + fileName);
      vmBus_send("wroteFile", file);
      return contents;
    } catch (Exception __e) {
      throw rethrow(__e);
    }
  }

  static public byte[] saveBinaryFile(File fileName, byte[] contents) {
    return saveBinaryFile(fileName.getPath(), contents);
  }

  static public File getGlobalCache() {
    File file = new File(javaxCachesDir(), "Binary Snippets");
    file.mkdirs();
    return file;
  }

  static public String dataSnippetLink(String snippetID) {
    long id = parseSnippetID(snippetID);
    if (id >= 1100000 && id < 1200000)
      return imageServerURL() + id;
    if (id >= 1200000 && id < 1300000) {
      String pw = muricaPassword();
      if (empty(pw))
        throw fail("Please set 'murica password by running #1008829");
      return "https://botcompany.de/files/" + id + "?_pass=" + pw;
    }
    return fileServerURL() + "/" + id;
  }

  static public String tb_mainServer_default = "https://code.botcompany.de:9898";

  static public Object tb_mainServer_override;

  static public String tb_mainServer() {
    if (tb_mainServer_override != null)
      return (String) callF(tb_mainServer_override);
    return trim(loadTextFile(tb_mainServer_file(), tb_mainServer_default));
  }

  static public File tb_mainServer_file() {
    return getProgramFile("#1001638", "mainserver.txt");
  }

  static public boolean tb_mainServer_isDefault() {
    return eq(tb_mainServer(), tb_mainServer_default);
  }

  static public <B, A extends B> A addAndReturn(Collection<B> c, A a) {
    if (c != null)
      c.add(a);
    return a;
  }

  static public void loadBinaryPageToFile(String url, File file) {
    try {
      print("Loading " + url);
      loadBinaryPageToFile(openConnection(new URL(url)), file);
    } catch (Exception __e) {
      throw rethrow(__e);
    }
  }

  static public void loadBinaryPageToFile(URLConnection con, File file) {
    try {
      setHeaders(con);
      loadBinaryPageToFile_noHeaders(con, file);
    } catch (Exception __e) {
      throw rethrow(__e);
    }
  }

  static public void loadBinaryPageToFile_noHeaders(URLConnection con, File file) {
    try {
      File ftemp = new File(f2s(file) + "_temp");
      FileOutputStream buf = newFileOutputStream(mkdirsFor(ftemp));
      try {
        InputStream inputStream = con.getInputStream();
        long len = 0;
        try {
          len = con.getContentLength();
        } catch (Throwable e) {
          printStackTrace(e);
        }
        String pat = "  {*}" + (len != 0 ? "/" + len : "") + " bytes loaded.";
        copyStreamWithPrints(inputStream, buf, pat);
        inputStream.close();
        buf.close();
        file.delete();
        renameFile_assertTrue(ftemp, file);
      } finally {
        if (buf != null)
          buf.close();
      }
    } catch (Exception __e) {
      throw rethrow(__e);
    }
  }

  static public URLConnection openConnection(String url) {
    try {
      return openConnection(new URL(url));
    } catch (Exception __e) {
      throw rethrow(__e);
    }
  }

  static public URLConnection openConnection(URL url) {
    try {
      ping();
      callOpt(javax(), "recordOpenURLConnection", str(url));
      return url.openConnection();
    } catch (Exception __e) {
      throw rethrow(__e);
    }
  }

  static public long psI(String snippetID) {
    return parseSnippetID(snippetID);
  }

  static public List<String> allToString(Iterable c) {
    List<String> l = new ArrayList();
    for (Object o : unnull(c)) l.add(str(o));
    return l;
  }

  static public List<String> allToString(Object[] c) {
    List<String> l = new ArrayList();
    for (Object o : unnull(c)) l.add(str(o));
    return l;
  }

  static public boolean byteArrayStartsWith(byte[] a, byte[] b) {
    if (a == null || b == null)
      return false;
    if (a.length < b.length)
      return false;
    for (int i = 0; i < b.length; i++) if (a[i] != b[i])
      return false;
    return true;
  }

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

  static public List collectField(Iterable c, String field) {
    List l = new ArrayList();
    if (c != null)
      for (Object a : c) l.add(getOpt(a, field));
    return l;
  }

  static public List collectField(String field, Iterable c) {
    return collectField(c, field);
  }

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

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

  static public boolean possibleMD5(String s) {
    return isMD5(s);
  }

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

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

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

  static public int showForm_leftWidth_safetyMargin = 10;

  static public int showForm_leftWidth(List<List<JComponent>> l) {
    forEachLevel2(l, x -> vmBus_send("updateLayoutNow", x));
    int minW = 0;
    for (List<JComponent> row : l) minW = max(minW, getMinimumSize(first(row)).width);
    return minW + or((Integer) vmBus_query("formSafetyMargin"), showForm_leftWidth_safetyMargin);
  }

  static public <A extends Component> A jMinWidthAtLeast(int w, final A c) {
    if (c == null)
      return null;
    return swing(new F0<A>() {

      public A get() {
        try {
          Dimension size = c.getMinimumSize();
          Dimension d = new Dimension(max(w, size.width), size.height);
          c.setMinimumSize(d);
          return jPreferWidth(d.width, c);
        } catch (Exception __e) {
          throw rethrow(__e);
        }
      }

      public String toString() {
        return "Dimension size = c.getMinimumSize();\r\n    Dimension d = new Dimension(max(w, ...";
      }
    });
  }

  static public void setComponentID(Component c, String id) {
    if (c != null)
      componentID_map.put(c, id);
  }

  static public List mapLL(Object f, Object... data) {
    return map(f, ll(data));
  }

  static public <A, B> List<B> mapLL(IF1<A, B> f, A... data) {
    return map(f, ll(data));
  }

  static public JComponent wrapForSmartAdd_jComponent(Object o) {
    return componentToJComponent(wrapForSmartAdd(o));
  }

  static public boolean isRunnable(Object o) {
    return o instanceof Runnable || hasMethod(o, "get");
  }

  static public String showFormSubmitButtonName() {
    return "Submit";
  }

  static public void disposeInternalFrame(Component c) {
    final JInternalFrame f = getInternalFrame(c);
    if (f != null) {
      swing(() -> {
        vmBus_send("disposingInternalFrame", f);
        f.dispose();
      });
    }
  }

  static public void disposeFrame(final Component c) {
    disposeWindow(c);
  }

  static public void onEnterInAllTextFields(JComponent c, Runnable action) {
    if (action == null)
      return;
    for (Component tf : allChildren(c)) onEnterIfTextField(tf, action);
  }

  static public void onEnterInAllTextFields(List c, Runnable action) {
    for (Object o : unnull(c)) if (o instanceof JComponent)
      onEnterInAllTextFields(((JComponent) o), action);
  }

  static public <A> List<A> concatLists(Iterable<A>... lists) {
    List<A> l = new ArrayList();
    if (lists != null)
      for (Iterable<A> list : lists) addAll(l, list);
    return l;
  }

  static public <A> List<A> concatLists(Collection<? extends Iterable<A>> lists) {
    List<A> l = new ArrayList();
    if (lists != null)
      for (Iterable<A> list : lists) addAll(l, list);
    return l;
  }

  static public void clickButton(final JButton b) {
    if (b != null) {
      swing(() -> {
        if (b.isEnabled())
          b.doClick();
      });
    }
  }

  static public <A extends JComponent> A makeBold(final A c) {
    if (c != null) {
      swing(() -> {
        c.setFont(c.getFont().deriveFont(java.awt.Font.BOLD));
      });
    }
    return c;
  }

  static public Map<Component, String> componentID_map = weakHashMap();

  static public String componentID(Component c) {
    return c == null ? null : componentID_map.get(c);
  }

  static public JDesktopPane mainDesktopPane_value;

  static public JDesktopPane mainDesktopPane() {
    return mainDesktopPane_value;
  }

  static public JPanel showInternalFrameFormTitled(final JDesktopPane desktop, final String title, final Object... _parts) {
    JPanel panel = showForm_makePanel(true, _parts);
    showForm_makeInternalFrame(desktop, title, panel);
    return panel;
  }

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

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

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

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

  static public <A> A liftLast(List<A> l) {
    if (empty(l))
      return null;
    int i = l(l) - 1;
    A a = l.get(i);
    l.remove(i);
    return a;
  }

  static public <A> List<A> liftLast(int n, List<A> l) {
    int i = l(l) - n;
    List<A> part = cloneSubList(l, i);
    removeSubList(l, i);
    return part;
  }

  static public int shorten_default = 100;

  static public String shorten(CharSequence s) {
    return shorten(s, shorten_default);
  }

  static public String shorten(CharSequence s, int max) {
    return shorten(s, max, "...");
  }

  static public String shorten(CharSequence s, int max, String shortener) {
    if (s == null)
      return "";
    if (max < 0)
      return str(s);
    return s.length() <= max ? str(s) : subCharSequence(s, 0, min(s.length(), max - l(shortener))) + shortener;
  }

  static public String shorten(int max, CharSequence s) {
    return shorten(s, max);
  }

  static public int parseHexChar(char c) {
    if (c >= '0' && c <= '9')
      return charDiff(c, '0');
    if (c >= 'a' && c <= 'f')
      return charDiff(c, 'a') + 10;
    if (c >= 'A' && c <= 'F')
      return charDiff(c, 'A') + 10;
    return -1;
  }

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

  static public Throwable _storeException_value;

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

  static public int loadPage_defaultTimeout = 60000;

  static public ThreadLocal<String> loadPage_charset = new ThreadLocal();

  static public boolean loadPage_allowGzip = true, loadPage_debug;

  static public boolean loadPage_anonymous = false;

  static public int loadPage_verboseness = 100000;

  static public int loadPage_retries = 1;

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

  static volatile public int loadPage_forcedTimeout;

  static public ThreadLocal<Integer> loadPage_forcedTimeout_byThread = new ThreadLocal();

  static public ThreadLocal<Map<String, List<String>>> loadPage_responseHeaders = new ThreadLocal();

  static public ThreadLocal<Map<String, String>> loadPage_extraHeaders = new ThreadLocal();

  static public ThreadLocal<Long> loadPage_sizeLimit = new ThreadLocal();

  public static String loadPageSilently(String url) {
    try {
      return loadPageSilently(new URL(loadPage_preprocess(url)));
    } catch (Exception __e) {
      throw rethrow(__e);
    }
  }

  public static String loadPageSilently(URL url) {
    try {
      if (!networkAllowanceTest(str(url)))
        throw fail("Not allowed: " + url);
      IOException e = null;
      for (int tries = 0; tries < loadPage_retries; tries++) try {
        URLConnection con = loadPage_openConnection(url);
        return loadPage(con, url);
      } catch (IOException _e) {
        e = _e;
        if (loadPage_debug)
          print(exceptionToStringShort(e));
        if (tries < loadPage_retries - 1)
          sleepSeconds(1);
      }
      throw e;
    } catch (Exception __e) {
      throw rethrow(__e);
    }
  }

  static public String loadPage_preprocess(String url) {
    if (url.startsWith("tb/"))
      url = tb_mainServer() + "/" + url;
    if (url.indexOf("://") < 0)
      url = "http://" + url;
    return url;
  }

  static public String loadPage(String url) {
    try {
      url = loadPage_preprocess(url);
      if (!isTrue(loadPage_silent.get()))
        printWithTime("Loading: " + hideCredentials(url));
      return loadPageSilently(new URL(url));
    } catch (Exception __e) {
      throw rethrow(__e);
    }
  }

  static public String loadPage(URL url) {
    return loadPage(url.toExternalForm());
  }

  static public String loadPage(URLConnection con, URL url) throws IOException {
    return loadPage(con, url, true);
  }

  static public String loadPage(URLConnection con, URL url, boolean addHeaders) throws IOException {
    Map<String, String> extraHeaders = getAndClearThreadLocal(loadPage_extraHeaders);
    Long limit = optPar(loadPage_sizeLimit);
    if (addHeaders)
      try {
        if (!loadPage_anonymous)
          setHeaders(con);
        if (loadPage_allowGzip)
          con.setRequestProperty("Accept-Encoding", "gzip");
        con.setRequestProperty("X-No-Cookies", "1");
        for (String key : keys(extraHeaders)) con.setRequestProperty(key, extraHeaders.get(key));
      } catch (Throwable e) {
      }
    vm_generalSubMap("URLConnection per thread").put(currentThread(), con);
    loadPage_responseHeaders.set(con.getHeaderFields());
    InputStream in = null;
    try {
      in = urlConnection_getInputStream(con);
      if (loadPage_debug)
        print("Put stream in map: " + currentThread());
      String contentType = con.getContentType();
      if (contentType == null) {
        throw new IOException("Page could not be read: " + hideCredentials(url));
      }
      String charset = loadPage_charset == null ? null : loadPage_charset.get();
      if (charset == null)
        charset = loadPage_guessCharset(contentType);
      if ("gzip".equals(con.getContentEncoding())) {
        if (loadPage_debug)
          print("loadPage: Using gzip.");
        in = newGZIPInputStream(in);
      }
      Reader r;
      try {
        r = new InputStreamReader(in, unquote(charset));
      } catch (UnsupportedEncodingException e) {
        print(toHex(utf8(charset)));
        throw e;
      }
      boolean silent = isTrue(loadPage_silent.get());
      StringBuilder buf = new StringBuilder();
      int n = 0;
      while (limit == null || n < limit) {
        ping();
        int ch = r.read();
        if (ch < 0)
          break;
        buf.append((char) ch);
        ++n;
        if (!silent && (n % loadPage_verboseness) == 0)
          print("  " + n + " chars read");
      }
      return buf.toString();
    } finally {
      if (loadPage_debug)
        print("loadPage done");
      vm_generalSubMap("URLConnection per thread").remove(currentThread());
      if (in != null)
        in.close();
    }
  }

  static public String loadPage_guessCharset(String contentType) {
    Matcher m = regexpMatcher("text/[a-z]+;\\s*charset=([^\\s]+)\\s*", contentType);
    String match = m.matches() ? m.group(1) : null;
    if (loadPage_debug)
      print("loadPage: contentType=" + contentType + ", match: " + match);
    return or(match, "UTF-8");
  }

  static public URLConnection loadPage_openConnection(URL url) {
    URLConnection con = openConnection(url);
    int timeout = toInt(loadPage_forcedTimeout_byThread.get());
    if (timeout == 0)
      timeout = loadPage_forcedTimeout;
    if (timeout != 0)
      setURLConnectionTimeouts(con, loadPage_forcedTimeout);
    else
      setURLConnectionDefaultTimeouts(con, loadPage_defaultTimeout);
    return con;
  }

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

  static public void setHeaders(URLConnection con) throws IOException {
    String computerID = getComputerID_quick();
    if (computerID != null)
      try {
        con.setRequestProperty("X-ComputerID", computerID);
        con.setRequestProperty("X-OS", System.getProperty("os.name") + " " + System.getProperty("os.version"));
      } catch (Throwable e) {
      }
  }

  static public <A> A println(A a) {
    return print(a);
  }

  static public FileOutputStream newFileOutputStream(File path) throws IOException {
    return newFileOutputStream(path.getPath());
  }

  static public FileOutputStream newFileOutputStream(String path) throws IOException {
    return newFileOutputStream(path, false);
  }

  static public FileOutputStream newFileOutputStream(File path, boolean append) throws IOException {
    return newFileOutputStream(path.getPath(), append);
  }

  static public FileOutputStream newFileOutputStream(String path, boolean append) throws IOException {
    mkdirsForFile(path);
    FileOutputStream f = new FileOutputStream(path, append);
    _registerIO(f, path, true);
    return f;
  }

  static public String imageServerURL() {
    return or2(trim(loadTextFile(javaxDataDir("image-server-url.txt"))), "http://botcompany.de/images/raw/");
  }

  static volatile public boolean muricaPassword_pretendNotAuthed = false;

  static public String muricaPassword() {
    if (muricaPassword_pretendNotAuthed)
      return null;
    return trim(loadTextFile(muricaPasswordFile()));
  }

  static public String fileServerURL() {
    return "https://botcompany.de/files";
  }

  static public String loadTextFile(String fileName) {
    return loadTextFile(fileName, null);
  }

  static public String loadTextFile(File f, String defaultContents) {
    return loadTextFile(f, defaultContents, "UTF-8");
  }

  static public String loadTextFile(File f, String defaultContents, String encoding) {
    try {
      checkFileNotTooBigToRead(f);
      if (f == null || !f.exists())
        return defaultContents;
      FileInputStream fileInputStream = new FileInputStream(f);
      InputStreamReader inputStreamReader = new InputStreamReader(fileInputStream, encoding);
      return loadTextFile(inputStreamReader);
    } catch (Exception __e) {
      throw rethrow(__e);
    }
  }

  public static String loadTextFile(File fileName) {
    return loadTextFile(fileName, null);
  }

  static public String loadTextFile(String fileName, String defaultContents) {
    return fileName == null ? defaultContents : loadTextFile(newFile(fileName), defaultContents);
  }

  static public String loadTextFile(Reader reader) throws IOException {
    StringBuilder builder = new StringBuilder();
    try {
      char[] buffer = new char[1024];
      int n;
      while (-1 != (n = reader.read(buffer))) builder.append(buffer, 0, n);
    } finally {
      reader.close();
    }
    return str(builder);
  }

  static public File getProgramFile(String progID, String fileName) {
    if (new File(fileName).isAbsolute())
      return new File(fileName);
    return new File(getProgramDir(progID), fileName);
  }

  static public File getProgramFile(String fileName) {
    return getProgramFile(getProgramID(), fileName);
  }

  static public void copyStreamWithPrints(InputStream in, OutputStream out, String pat) {
    try {
      byte[] buf = new byte[65536];
      int total = 0;
      while (true) {
        int n = in.read(buf);
        if (n <= 0)
          return;
        out.write(buf, 0, n);
        if ((total + n) / 100000 > total / 100000)
          print(pat.replace("{*}", str(roundDownTo(100000, total))));
        total += n;
      }
    } catch (Exception __e) {
      throw rethrow(__e);
    }
  }

  static public File renameFile_assertTrue(File a, File b) {
    try {
      if (a.equals(b))
        return b;
      if (!a.exists())
        throw fail("Source file not found: " + f2s(a));
      if (b.exists())
        throw fail("Target file exists: " + f2s(b));
      mkdirsForFile(b);
      if (!a.renameTo(b))
        throw fail("Can't rename " + f2s(a) + " to " + f2s(b));
      return b;
    } catch (Exception __e) {
      throw rethrow(__e);
    }
  }

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

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

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

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

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

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

  static public boolean isMD5(String s) {
    return l(s) == 32 && isLowerHexString(s);
  }

  static public <A, B extends Collection<A>> void forEachLevel2(Iterable<B> l, IVF1<A> f) {
    if (l != null)
      for (B b : l) forEach(b, f);
  }

  static public <A, B extends Collection<A>> void forEachLevel2(IVF1<A> f, Iterable<B> l) {
    forEachLevel2(f, l);
  }

  static public Dimension getMinimumSize(final Component c) {
    return c == null ? null : swing(new F0<Dimension>() {

      public Dimension get() {
        try {
          return c.getMinimumSize();
        } catch (Exception __e) {
          throw rethrow(__e);
        }
      }

      public String toString() {
        return "return c.getMinimumSize();";
      }
    });
  }

  static public <A extends Component> A jPreferWidth(int w, A c) {
    {
      swing(() -> {
        Dimension size = c.getPreferredSize();
        c.setPreferredSize(new Dimension(w, size.height));
      });
    }
    return c;
  }

  static public JInternalFrame getInternalFrame(final Object _o) {
    return _o == null ? null : swing(new F0<JInternalFrame>() {

      public JInternalFrame get() {
        try {
          Object o = _o;
          if (o instanceof ButtonGroup)
            o = first(buttonsInGroup((ButtonGroup) o));
          if (!(o instanceof Component))
            return null;
          Component c = (Component) o;
          while (c != null) {
            if (c instanceof JInternalFrame)
              return (JInternalFrame) c;
            c = c.getParent();
          }
          return null;
        } catch (Exception __e) {
          throw rethrow(__e);
        }
      }

      public String toString() {
        return "O o = _o;\r\n    if (o instanceof ButtonGroup) o = first(buttonsInGroup((Button...";
      }
    });
  }

  static public List<Component> allChildren(Component c) {
    return childrenOfType(c, Component.class);
  }

  static public void onEnterIfTextField(Component c, Runnable action) {
    if (action == null)
      return;
    if (c instanceof JTextField)
      onEnter(((JTextField) c), action);
    else if (c instanceof JComboBox)
      onEnter(((JComboBox) c), action);
  }

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

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

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

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

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

  static public JInternalFrame showForm_makeInternalFrame(JDesktopPane desktop, String title, JPanel panel) {
    JInternalFrame f = addInternalFrame(desktop, title, withMargin(panel));
    minInternalFrameWidth(f, 400);
    packInternalFrameVertically(f);
    centerInternalFrame(f);
    return f;
  }

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

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

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

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

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

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

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

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

  static public CharSequence subCharSequence(CharSequence s, int x, int y) {
    if (s == null)
      return null;
    if (x < 0)
      x = 0;
    if (x >= s.length())
      return "";
    if (y < x)
      y = x;
    if (y > s.length())
      y = s.length();
    return s.subSequence(x, y);
  }

  static public int charDiff(char a, char b) {
    return (int) a - (int) b;
  }

  static public int charDiff(String a, char b) {
    return charDiff(stringToChar(a), b);
  }

  static public boolean networkAllowanceTest(String url) {
    return isAllowed("networkAllowanceTest", url);
  }

  static public String exceptionToStringShort(Throwable e) {
    lastException(e);
    e = getInnerException(e);
    String msg = hideCredentials(unnull(e.getMessage()));
    if (msg.indexOf("Error") < 0 && msg.indexOf("Exception") < 0)
      return baseClassName(e) + prependIfNempty(": ", msg);
    else
      return msg;
  }

  static public void sleepSeconds(double s) {
    if (s > 0)
      sleep(round(s * 1000));
  }

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

  static public <A> A printWithTime(String s, A a) {
    print(hmsWithColons() + ": " + s, a);
    return a;
  }

  static public <A> A optPar(ThreadLocal<A> tl, A defaultValue) {
    A a = tl.get();
    if (a != null) {
      tl.set(null);
      return a;
    }
    return defaultValue;
  }

  static public <A> A optPar(ThreadLocal<A> tl) {
    return optPar(tl, null);
  }

  static public Object optPar(Object[] params, String name) {
    return optParam(params, name);
  }

  static public Object optPar(String name, Object[] params) {
    return optParam(params, name);
  }

  static public Object optPar(String name, Map params) {
    return optParam(name, params);
  }

  static public <A> A optPar(Object[] params, String name, A defaultValue) {
    return optParam(params, name, defaultValue);
  }

  static public <A> A optPar(String name, Object[] params, A defaultValue) {
    return optParam(params, name, defaultValue);
  }

  static public Map vm_generalSubMap(Object name) {
    synchronized (vm_generalMap()) {
      Map map = (Map) (vm_generalMap_get(name));
      if (map == null)
        vm_generalMap_put(name, map = synchroMap());
      return map;
    }
  }

  static public InputStream urlConnection_getInputStream(URLConnection con) throws IOException {
    return con.getInputStream();
  }

  static public String unquote(String s) {
    if (s == null)
      return null;
    if (startsWith(s, '[')) {
      int i = 1;
      while (i < s.length() && s.charAt(i) == '=') ++i;
      if (i < s.length() && s.charAt(i) == '[') {
        String m = s.substring(1, i);
        if (s.endsWith("]" + m + "]"))
          return s.substring(i + 1, s.length() - i - 1);
      }
    }
    if (s.length() > 1) {
      char c = s.charAt(0);
      if (c == '\"' || c == '\'') {
        int l = endsWith(s, c) ? s.length() - 1 : s.length();
        StringBuilder sb = new StringBuilder(l - 1);
        for (int i = 1; i < l; i++) {
          char ch = s.charAt(i);
          if (ch == '\\') {
            char nextChar = (i == l - 1) ? '\\' : s.charAt(i + 1);
            if (nextChar >= '0' && nextChar <= '7') {
              String code = "" + nextChar;
              i++;
              if ((i < l - 1) && s.charAt(i + 1) >= '0' && s.charAt(i + 1) <= '7') {
                code += s.charAt(i + 1);
                i++;
                if ((i < l - 1) && s.charAt(i + 1) >= '0' && s.charAt(i + 1) <= '7') {
                  code += s.charAt(i + 1);
                  i++;
                }
              }
              sb.append((char) Integer.parseInt(code, 8));
              continue;
            }
            switch(nextChar) {
              case '\"':
                ch = '\"';
                break;
              case '\\':
                ch = '\\';
                break;
              case 'b':
                ch = '\b';
                break;
              case 'f':
                ch = '\f';
                break;
              case 'n':
                ch = '\n';
                break;
              case 'r':
                ch = '\r';
                break;
              case 't':
                ch = '\t';
                break;
              case '\'':
                ch = '\'';
                break;
              case 'u':
                if (i >= l - 5) {
                  ch = 'u';
                  break;
                }
                int code = Integer.parseInt("" + s.charAt(i + 2) + s.charAt(i + 3) + s.charAt(i + 4) + s.charAt(i + 5), 16);
                sb.append(Character.toChars(code));
                i += 5;
                continue;
              default:
                ch = nextChar;
            }
            i++;
          }
          sb.append(ch);
        }
        return sb.toString();
      }
    }
    return s;
  }

  static public String toHex(byte[] bytes) {
    return bytesToHex(bytes);
  }

  static public String toHex(byte[] bytes, int ofs, int len) {
    return bytesToHex(bytes, ofs, len);
  }

  static public byte[] utf8(String s) {
    return toUtf8(s);
  }

  static public Matcher regexpMatcher(String pat, String s) {
    return compileRegexp(pat).matcher(unnull(s));
  }

  static public URLConnection setURLConnectionTimeouts(URLConnection con, long timeout) {
    con.setConnectTimeout(toInt(timeout));
    con.setReadTimeout(toInt(timeout));
    if (con.getConnectTimeout() != timeout || con.getReadTimeout() != timeout)
      print("Warning: Timeouts not set by JDK.");
    return con;
  }

  static public URLConnection setURLConnectionDefaultTimeouts(URLConnection con, long timeout) {
    if (con.getConnectTimeout() == 0) {
      con.setConnectTimeout(toInt(timeout));
      if (con.getConnectTimeout() != timeout)
        print("Warning: URL connect timeout not set by JDK.");
    }
    if (con.getReadTimeout() == 0) {
      con.setReadTimeout(toInt(timeout));
      if (con.getReadTimeout() != timeout)
        print("Warning: URL read timeout not set by JDK.");
    }
    return con;
  }

  static public String getComputerID_quick() {
    return computerID();
  }

  static public File javaxDataDir_dir;

  static public File javaxDataDir() {
    return javaxDataDir_dir != null ? javaxDataDir_dir : new File(userHome(), "JavaX-Data");
  }

  static public File javaxDataDir(String... subs) {
    return newFile(javaxDataDir(), subs);
  }

  static public File muricaPasswordFile() {
    return new File(javaxSecretDir(), "murica/muricaPasswordFile");
  }

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

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

  static public File getProgramDir() {
    return programDir();
  }

  static public File getProgramDir(String snippetID) {
    return programDir(snippetID);
  }

  static public int roundDownTo(int n, int x) {
    return x / n * n;
  }

  static public long roundDownTo(long n, long x) {
    return x / n * n;
  }

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

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

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

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

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

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

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

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

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

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

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

  static public boolean isLowerHexString(String s) {
    for (int i = 0; i < l(s); i++) {
      char c = s.charAt(i);
      if (c >= '0' && c <= '9' || c >= 'a' && c <= 'f') {
      } else
        return false;
    }
    return true;
  }

  static public List<AbstractButton> buttonsInGroup(ButtonGroup g) {
    if (g == null)
      return ll();
    return asList(g.getElements());
  }

  static public JTextField onEnter(JTextField tf, JButton btn) {
    if (btn != null)
      onEnter(tf, new Runnable() {

        public void run() {
          try {
            clickButton(btn);
          } catch (Exception __e) {
            throw rethrow(__e);
          }
        }

        public String toString() {
          return "clickButton(btn)";
        }
      });
    return tf;
  }

  static public JTextField onEnter(JTextField tf, Object action) {
    if (action == null || tf == null)
      return tf;
    tf.addActionListener(new java.awt.event.ActionListener() {

      public void actionPerformed(java.awt.event.ActionEvent _evt) {
        try {
          tf.selectAll();
          callF(action);
        } catch (Throwable __e) {
          messageBox(__e);
        }
      }
    });
    return tf;
  }

  static public JButton onEnter(JButton btn, final Object action) {
    if (action == null || btn == null)
      return btn;
    btn.addActionListener(actionListener(action));
    return btn;
  }

  static public JList onEnter(JList list, Object action) {
    list.addKeyListener(enterKeyListener(rCallOnSelectedListItem(list, action)));
    return list;
  }

  static public JComboBox onEnter(final JComboBox cb, Runnable action) {
    {
      swing(() -> {
        if (cb.isEditable()) {
          JTextField text = (JTextField) cb.getEditor().getEditorComponent();
          onEnter(text, action);
        } else {
          cb.getInputMap().put(KeyStroke.getKeyStroke("ENTER"), "enter");
          cb.getActionMap().put("enter", abstractAction("", new Runnable() {

            public void run() {
              try {
                cb.hidePopup();
                callF(action);
              } catch (Exception __e) {
                throw rethrow(__e);
              }
            }

            public String toString() {
              return "cb.hidePopup(); callF(action);";
            }
          }));
        }
      });
    }
    return cb;
  }

  static public JTable onEnter(final JTable table, final Object action) {
    table.getInputMap(JComponent.WHEN_ANCESTOR_OF_FOCUSED_COMPONENT).put(KeyStroke.getKeyStroke(KeyEvent.VK_ENTER, 0), "Enter");
    table.getActionMap().put("Enter", new AbstractAction() {

      public void actionPerformed(ActionEvent e) {
        callF(action, table.getSelectedRow());
      }
    });
    return table;
  }

  static public JTextField onEnter(Runnable action, JTextField tf) {
    return onEnter(tf, action);
  }

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

  static public ThreadLocal<Integer> addInternalFrame_layer = new ThreadLocal();

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

  static public JInternalFrame addInternalFrame(final JDesktopPane desktop, final String title, final int x, final int y, final int w, final int h) {
    return addInternalFrame(desktop, title, x, y, w, h, null);
  }

  static public JInternalFrame addInternalFrame(final JDesktopPane desktop, final String title, final int x, final int y, final int w, final int h, final Component contents) {
    return addInternalFrame(desktop, title, rect(x, y, w, h), contents);
  }

  static public JInternalFrame addInternalFrame(final JDesktopPane desktop, final String title, final Component contents) {
    return addInternalFrame(desktop, title, null, contents);
  }

  static public JInternalFrame addInternalFrame(final JDesktopPane desktop, final String title, final Rect r, final Component contents) {
    final boolean dontSelect = isTrue(optParam(addInternalFrame_dontSelect));
    final boolean toBack = isTrue(optParam(addInternalFrame_toBack));
    final Integer layer = optParam(addInternalFrame_layer);
    return swing(new F0<JInternalFrame>() {

      public JInternalFrame get() {
        try {
          JInternalFrame frame;
          if (contents instanceof JInternalFrame)
            frame = (JInternalFrame) contents;
          else {
            frame = jInternalFrame(title);
            setInternalFrameContents(frame, contents);
          }
          frame.setVisible(true);
          desktop.add(frame, layer);
          if (r != null)
            setBounds(frame, r);
          else
            internalFrameDefaultPosition(frame);
          if (dontSelect)
            if (toBack)
              frame.toBack();
            else
              frame.toFront();
          else
            frame.setSelected(true);
          return fixInternalFrame(frame);
        } catch (Exception __e) {
          throw rethrow(__e);
        }
      }

      public String toString() {
        return "JInternalFrame frame;\r\n    if (contents instanceof JInternalFrame)\r\n      fra...";
      }
    });
  }

  static public JInternalFrame addInternalFrame(JDesktopPane desktop, String title) {
    return addInternalFrame(desktop, title, jpanel());
  }

  static public JInternalFrame minInternalFrameWidth(final JInternalFrame frame, final int w) {
    {
      swing(() -> {
        if (frame != null && frame.getWidth() < w)
          frame.setSize(w, frame.getHeight());
      });
    }
    return frame;
  }

  static public JInternalFrame minInternalFrameWidth(int w, JInternalFrame frame) {
    return minInternalFrameWidth(frame, w);
  }

  static public <A extends Component> A packInternalFrameVertically(A c) {
    return packInternalFrameVertically(-1, c);
  }

  static public <A extends Component> A packInternalFrameVertically(int width, A c) {
    final JInternalFrame win = getInternalFrame(c);
    if (win == null)
      return c;
    final int w = width < 0 ? win.getWidth() : width;
    {
      swing(() -> {
        win.pack();
        win.setSize(w, win.getHeight());
        fixInternalFrame(win);
      });
    }
    return c;
  }

  static public JInternalFrame centerInternalFrame(final JInternalFrame f) {
    {
      swing(() -> {
        Container c = f.getParent();
        if (c != null) {
          f.setLocation((c.getWidth() - f.getWidth()) / 2, (c.getHeight() - f.getHeight()) / 2);
        }
      });
    }
    return f;
  }

  static public JInternalFrame centerInternalFrame(final int w, final int h, final JInternalFrame f) {
    {
      swing(() -> {
        f.setSize(w, h);
      });
    }
    return centerInternalFrame(f);
  }

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

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

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

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

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

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

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

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

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

  static public char stringToChar(String s) {
    if (l(s) != 1)
      throw fail("bad stringToChar: " + s);
    return firstChar(s);
  }

  static volatile public Object isAllowed_function;

  static volatile public boolean isAllowed_all = true;

  static public boolean isAllowed(String askingMethod, Object... args) {
    Object f = vm_generalMap_get("isAllowed_function");
    if (f != null && !isTrue(callF(f, askingMethod, args)))
      return false;
    return isAllowed_all || isTrue(callF(isAllowed_function, askingMethod, args));
  }

  static public Throwable getInnerException(Throwable e) {
    if (e == null)
      return null;
    while (e.getCause() != null) e = e.getCause();
    return e;
  }

  static public Throwable getInnerException(Runnable r) {
    return getInnerException(getException(r));
  }

  static public String baseClassName(String className) {
    return substring(className, className.lastIndexOf('.') + 1);
  }

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

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

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

  static public String round(String s) {
    return roundBracket(s);
  }

  static public Complex round(Complex c) {
    return new Complex(round(c.re), round(c.im));
  }

  static public String hmsWithColons() {
    return hmsWithColons(now());
  }

  static public String hmsWithColons(long time) {
    return new SimpleDateFormat("HH:mm:ss").format(time);
  }

  static public <A> A optParam(ThreadLocal<A> tl, A defaultValue) {
    return optPar(tl, defaultValue);
  }

  static public <A> A optParam(ThreadLocal<A> tl) {
    return optPar(tl);
  }

  static public Object optParam(String name, Map params) {
    return mapGet(params, name);
  }

  static public <A> A optParam(Object[] opt, String name, A defaultValue) {
    int n = l(opt);
    if (n == 1 && opt[0] instanceof Map) {
      Map map = (Map) (opt[0]);
      return map.containsKey(name) ? (A) map.get(name) : defaultValue;
    }
    if (!even(l(opt)))
      throw fail("Odd parameter length");
    for (int i = 0; i < l(opt); i += 2) if (eq(opt[i], name))
      return (A) opt[i + 1];
    return defaultValue;
  }

  static public Object optParam(Object[] opt, String name) {
    return optParam(opt, name, null);
  }

  static public Object optParam(String name, Object[] params) {
    return optParam(params, name);
  }

  public static String bytesToHex(byte[] bytes) {
    return bytesToHex(bytes, 0, bytes.length);
  }

  public static String bytesToHex(byte[] bytes, int ofs, int len) {
    StringBuilder stringBuilder = new StringBuilder(len * 2);
    for (int i = 0; i < len; i++) {
      String s = "0" + Integer.toHexString(bytes[ofs + i]);
      stringBuilder.append(s.substring(s.length() - 2, s.length()));
    }
    return stringBuilder.toString();
  }

  static public byte[] toUtf8(String s) {
    try {
      return s.getBytes(utf8charset());
    } catch (Exception __e) {
      throw rethrow(__e);
    }
  }

  static public Map<String, java.util.regex.Pattern> compileRegexp_cache = syncMRUCache(10);

  static public java.util.regex.Pattern compileRegexp(String pat) {
    java.util.regex.Pattern p = compileRegexp_cache.get(pat);
    if (p == null) {
      compileRegexp_cache.put(pat, p = java.util.regex.Pattern.compile(pat));
    }
    return p;
  }

  static public String _computerID;

  static public Lock computerID_lock = lock();

  public static String computerID() {
    if (_computerID == null) {
      Lock __0 = computerID_lock;
      lock(__0);
      try {
        if (_computerID != null)
          return _computerID;
        File file = computerIDFile();
        _computerID = loadTextFile(file.getPath());
        if (_computerID == null) {
          _computerID = loadTextFile(userDir(".tinybrain/computer-id"));
          if (_computerID == null)
            _computerID = makeRandomID(12, new SecureRandom());
          saveTextFile(file, _computerID);
        }
      } finally {
        unlock(__0);
      }
    }
    return _computerID;
  }

  static public File javaxSecretDir_dir;

  static public File javaxSecretDir() {
    return javaxSecretDir_dir != null ? javaxSecretDir_dir : new File(userHome(), "JavaX-Secret");
  }

  static public File javaxSecretDir(String sub) {
    return newFile(javaxSecretDir(), sub);
  }

  static public File programDir_mine;

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

  static public File programDir(String snippetID) {
    boolean me = sameSnippetID(snippetID, programID());
    if (programDir_mine != null && me)
      return programDir_mine;
    File dir = new File(javaxDataDir(), formatSnippetIDOpt(snippetID));
    if (me) {
      String c = caseID();
      if (nempty(c))
        dir = newFile(dir, c);
    }
    return dir;
  }

  static public File programDir(String snippetID, String subPath) {
    return new File(programDir(snippetID), subPath);
  }

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

  static public AbstractAction abstractAction(String name, final Object runnable) {
    return new AbstractAction(name) {

      public void actionPerformed(ActionEvent evt) {
        pcallF(runnable);
      }
    };
  }

  static public boolean jInternalFrame_iconifiable = true;

  static public JInternalFrame jInternalFrame() {
    return jInternalFrame("");
  }

  static public JInternalFrame jInternalFrame(final String title) {
    return swing(new F0<JInternalFrame>() {

      public JInternalFrame get() {
        try {
          JInternalFrame f = new JInternalFrame(title, true, true, true, jInternalFrame_iconifiable);
          f.setVisible(true);
          return f;
        } catch (Exception __e) {
          throw rethrow(__e);
        }
      }

      public String toString() {
        return "JInternalFrame f = new JInternalFrame(title, true, true, true, jInternalFrame...";
      }
    });
  }

  static public void setInternalFrameContents(final Component c, final Object contents) {
    {
      swing(() -> {
        JInternalFrame frame = getInternalFrame(c);
        if (frame == null)
          return;
        frame.getContentPane().removeAll();
        frame.getContentPane().setLayout(new BorderLayout());
        if (contents != null)
          frame.getContentPane().add(wrap(contents));
        revalidate(frame);
      });
    }
  }

  static public <A extends Component> A setBounds(final int x, final int y, final int w, final int h, final A a) {
    if (a != null) {
      swing(() -> {
        a.setBounds(x, y, w, h);
      });
    }
    return a;
  }

  static public <A extends Component> A setBounds(A a, Rect r) {
    if (a != null && r != null) {
      swing(() -> {
        a.setBounds(toRectangle(r));
      });
    }
    return a;
  }

  static public <A extends Component> A setBounds(A a, Rectangle r) {
    if (a != null && r != null) {
      swing(() -> {
        a.setBounds(r);
      });
    }
    return a;
  }

  static public <A extends Component> A setBounds(Rect r, A a) {
    return setBounds(a, r);
  }

  static public <A extends Component> A setBounds(A a, int x, int y, int w, int h) {
    return setBounds(x, y, w, h, a);
  }

  static public void internalFrameDefaultPosition(JInternalFrame f) {
    f.setSize(500, 300);
    centerInternalFrame(f);
  }

  static public int fixInternalFrame_borderTopLeft = 0;

  static public int fixInternalFrame_borderBottomRight = 40;

  static public JInternalFrame fixInternalFrame(final JInternalFrame f) {
    return swing(new F0<JInternalFrame>() {

      public JInternalFrame get() {
        try {
          Container c = f.getParent();
          if (c == null)
            return f;
          Rect r = toRect(f.getBounds());
          int a = fixInternalFrame_borderTopLeft, b = fixInternalFrame_borderBottomRight;
          Rect outer = new Rect(a, a, c.getWidth() - b, c.getHeight() - b);
          if (!rectContains(outer, r))
            f.setLocation(max(a, min(r.x, outer.x2())), max(a, min(r.y, outer.y2())));
          if (r.w > c.getWidth() || r.h > c.getHeight())
            f.setSize(c.getWidth() - a, c.getHeight() - a);
          return f;
        } catch (Exception __e) {
          throw rethrow(__e);
        }
      }

      public String toString() {
        return "Container c = f.getParent();\r\n    if (c == null) ret f;\r\n    Rect r = toRect(...";
      }
    });
  }

  static public char firstChar(String s) {
    return s.charAt(0);
  }

  static public Throwable getException(Runnable r) {
    try {
      callF(r);
      return null;
    } catch (Throwable e) {
      return e;
    }
  }

  static public String roundBracket(String s) {
    return "(" + s + ")";
  }

  static public String roundBracket(Object s) {
    return roundBracket(str(s));
  }

  static public long now_virtualTime;

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

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

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

  static public boolean even(int i) {
    return (i & 1) == 0;
  }

  static public boolean even(long i) {
    return (i & 1) == 0;
  }

  static public boolean even(BigInteger n) {
    return even(n.intValue());
  }

  static public Charset utf8charset_cache;

  static public Charset utf8charset() {
    if (utf8charset_cache == null)
      utf8charset_cache = utf8charset_load();
    return utf8charset_cache;
  }

  static public Charset utf8charset_load() {
    return Charset.forName("UTF-8");
  }

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

  static public File computerIDFile() {
    return javaxDataDir("Basic Info/computer-id.txt");
  }

  static public String makeRandomID(int length) {
    return makeRandomID(length, defaultRandomGenerator());
  }

  static public String makeRandomID(int length, Random random) {
    char[] id = new char[length];
    for (int i = 0; i < id.length; i++) id[i] = (char) ((int) 'a' + random.nextInt(26));
    return new String(id);
  }

  static public String makeRandomID(Random r, int length) {
    return makeRandomID(length, r);
  }

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

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

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

  static volatile public String caseID_caseID;

  static public String caseID() {
    return caseID_caseID;
  }

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

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

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

  static public File copyFile(File src, File dest) {
    try {
      FileInputStream inputStream = new FileInputStream(src.getPath());
      FileOutputStream outputStream = newFileOutputStream(dest.getPath());
      try {
        copyStream(inputStream, outputStream);
        inputStream.close();
      } finally {
        outputStream.close();
      }
      return dest;
    } catch (Exception __e) {
      throw rethrow(__e);
    }
  }

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

  public interface IImageRegions<Img extends WidthAndHeight> {

    public List<IImageRegion<Img>> regions();
  }

  static public class WithToolTip<A> extends Var<A> {

    final public WithToolTip<A> setToolTip(String toolTip) {
      return toolTip(toolTip);
    }

    public WithToolTip<A> toolTip(String toolTip) {
      this.toolTip = toolTip;
      return this;
    }

    final public String getToolTip() {
      return toolTip();
    }

    public String toolTip() {
      return toolTip;
    }

    public String toolTip;

    public WithToolTip() {
    }

    public WithToolTip(A value, String toolTip) {
      super(value);
      this.toolTip = toolTip;
    }

    public String toString() {
      return formatFunctionCall("WithToolTip", toolTip, get());
    }
  }

  static public class Var<A> implements IVar<A>, ISetter<A> {

    public Var() {
    }

    public Var(A v) {
      this.v = v;
    }

    public A v;

    public synchronized void set(A a) {
      if (v != a) {
        v = a;
        notifyAll();
      }
    }

    public synchronized A get() {
      return v;
    }

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

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

    public String toString() {
      return str(this.get());
    }
  }

  static public class G22Challenge extends G22LeftArrowScript {
  }

  static public class G22_TestScreenPanel implements IHasChangeListeners {

    public G22_TestScreenPanel() {
    }

    final public G22_TestScreenPanel setScript(String script) {
      return script(script);
    }

    public G22_TestScreenPanel script(String script) {
      if (!eq(this.script, script)) {
        this.script = script;
        change();
      }
      return this;
    }

    final public String getScript() {
      return script();
    }

    public String script() {
      return script;
    }

    public String script = "rasters";

    final public G22_TestScreenPanel setAnimate(boolean animate) {
      return animate(animate);
    }

    public G22_TestScreenPanel animate(boolean animate) {
      if (!eq(this.animate, animate)) {
        this.animate = animate;
        change();
      }
      return this;
    }

    final public boolean getAnimate() {
      return animate();
    }

    public boolean animate() {
      return animate;
    }

    public boolean animate = true;

    transient public List<Runnable> onChange;

    public G22_TestScreenPanel onChange(Runnable r) {
      onChange = syncAddOrCreate(onChange, r);
      return this;
    }

    public G22_TestScreenPanel removeChangeListener(Runnable r) {
      main.remove(onChange, r);
      return this;
    }

    public void change() {
      pcallFAll(onChange);
    }

    transient public Animation animation;

    transient public G22Utils g22utils = new G22Utils();

    transient public ImageSurface isInput;

    transient public JGazelleVScriptRunner scriptRunner;

    public void start() {
      scriptRunner = new JGazelleVScriptRunner(liveValue_hasChangeListeners(this, String.class, () -> script, x -> script = x));
      isInput = g22utils.stdImageSurface();
      awtEvery(isInput, 1000 / 20, new Runnable() {

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

        public String toString() {
          return "stepAnimation();";
        }
      });
    }

    public void stepAnimation() {
      if (!animate)
        return;
      if (animation == null) {
        animation = new AnimatedLine();
        animation.start();
      }
      animation.nextFrame();
      var img = whiteImage(animation.w, animation.h);
      animation.setGraphics(createGraphics(img));
      animation.paint();
      {
        if (isInput != null)
          isInput.setImage(img);
      }
      var ii = bwIntegralImage_withMeta(img);
      scriptRunner.parseAndRunOn(ii);
    }

    public JComponent visualize() {
      if (isInput == null)
        start();
      return centerAndSouthWithMargin(hsplit(northAndCenterWithMargin(centerAndEastWithMargin(jlabel("Input"), liveValueCheckBox("Animate", liveValue_hasChangeListeners(this, boolean.class, () -> animate, x -> animate(x)))), jscroll_centered_borderless(isInput)), northAndCenterWithMargin(centerAndEastWithMargin(jlabel("Output"), scriptRunner.lblScore), scriptRunner.scpScriptResult)), scriptRunner.scriptInputField());
    }
  }

  static public class G22Utils {

    final public G22Utils setBackgroundProcessesUI(BackgroundProcessesUI backgroundProcessesUI) {
      return backgroundProcessesUI(backgroundProcessesUI);
    }

    public G22Utils backgroundProcessesUI(BackgroundProcessesUI backgroundProcessesUI) {
      this.backgroundProcessesUI = backgroundProcessesUI;
      return this;
    }

    final public BackgroundProcessesUI getBackgroundProcessesUI() {
      return backgroundProcessesUI();
    }

    public BackgroundProcessesUI backgroundProcessesUI() {
      return backgroundProcessesUI;
    }

    public BackgroundProcessesUI backgroundProcessesUI;

    final public G22Utils setModule(Enterable module) {
      return module(module);
    }

    public G22Utils module(Enterable module) {
      this.module = module;
      return this;
    }

    final public Enterable getModule() {
      return module();
    }

    public Enterable module() {
      return module;
    }

    public Enterable module;

    final public G22Utils setMasterStuff(G22MasterStuff masterStuff) {
      return masterStuff(masterStuff);
    }

    public G22Utils masterStuff(G22MasterStuff masterStuff) {
      this.masterStuff = masterStuff;
      return this;
    }

    final public G22MasterStuff getMasterStuff() {
      return masterStuff();
    }

    public G22MasterStuff masterStuff() {
      return masterStuff;
    }

    public G22MasterStuff masterStuff;

    final public CombinedStringifier getStringifier() {
      return stringifier();
    }

    public CombinedStringifier stringifier() {
      return stringifier;
    }

    public CombinedStringifier stringifier = new CombinedStringifier(o -> o instanceof BufferedImage ? "Image (" + ((BufferedImage) o).getWidth() + "*" + ((BufferedImage) o).getHeight() + " px)" : null);

    public ImageSurface stdImageSurface() {
      var is = pixelatedImageSurface().setAutoZoomToDisplay(true).repaintInThread(false);
      is.specialPurposed = true;
      new ImageSurface_PositionToolTip(is);
      return is;
    }

    public ImageSurface stdImageSurface(MakesBufferedImage img) {
      return stdImageSurface(toBufferedImage(img));
    }

    public ImageSurface stdImageSurface(BufferedImage img) {
      var is = stdImageSurface();
      is.setImage(img);
      return is;
    }

    public String stringify(Object o) {
      return stringifier.toString(o);
    }

    transient public IVF1<GazelleV_LeftArrowScriptParser> modifyLeftArrowParser;

    public void modifyLeftArrowParser(GazelleV_LeftArrowScriptParser parser) {
      if (modifyLeftArrowParser != null)
        modifyLeftArrowParser.get(parser);
      else
        modifyLeftArrowParser_base(parser);
    }

    final public void modifyLeftArrowParser_fallback(IVF1<GazelleV_LeftArrowScriptParser> _f, GazelleV_LeftArrowScriptParser parser) {
      if (_f != null)
        _f.get(parser);
      else
        modifyLeftArrowParser_base(parser);
    }

    public void modifyLeftArrowParser_base(GazelleV_LeftArrowScriptParser parser) {
    }

    public GazelleV_LeftArrowScriptParser leftArrowParser() {
      GazelleV_LeftArrowScriptParser parser = new GazelleV_LeftArrowScriptParser();
      parser.g22utils(this);
      modifyLeftArrowParser(parser);
      return parser;
    }

    public void basicParserTest() {
      var parser = leftArrowParser();
      print("classContainerPrefixes", parser.classContainerPrefixes());
      assertEquals(pair(1, 2), parser.parse("new Pair 1 2").get());
    }

    public JLeftArrowScriptIDE leftArrowIDE() {
      JLeftArrowScriptIDE ide = new JLeftArrowScriptIDE();
      ide.g22utils(this);
      ide.modifyParser = modifyLeftArrowParser;
      return ide;
    }

    public File byteCodePath() {
      return assertNotNull(getBytecodePathForClass(this));
    }

    public ClassNameResolver classNameResolver_cache;

    public ClassNameResolver classNameResolver() {
      if (classNameResolver_cache == null)
        classNameResolver_cache = classNameResolver_load();
      return classNameResolver_cache;
    }

    public ClassNameResolver classNameResolver_load() {
      return new ClassNameResolver().byteCodePath(byteCodePath()).init();
    }

    public File databasesMotherDir() {
      return javaxDataDir("Gazelle-22");
    }

    public AutoCloseable enter() {
      return module == null ? null : module.enter();
    }

    public String defaultDBName() {
      return "Default";
    }

    public File lastOpenedDBFile() {
      return newFile(databasesMotherDir(), "Last Opened");
    }

    public String dbToOpen() {
      String name = loadTextFile(lastOpenedDBFile());
      if (nempty(name) && fileExists(newFile(databasesMotherDir(), name)))
        return name;
      return defaultDBName();
    }

    public void openedDB(File dbDir) {
      if (sameFile(databasesMotherDir(), dirOfFile(dbDir)))
        saveTextFile(lastOpenedDBFile(), fileName(dbDir));
    }
  }

  public interface IImageRegion<Img extends WidthAndHeight> {

    public default Img image() {
      return null;
    }

    public Object creator();

    public default int indexInCreator() {
      return 0;
    }

    public Rect bounds();

    public int numberOfPixels();

    public Pt firstPixel();

    public Iterator<Pt> pixelIterator();

    public boolean contains(int x, int y);

    public RGB color();

    public int brightness();
  }

  static public class SnPSettings implements IFieldsToList {

    static final public String _fieldOrder = "pixelRows colors";

    public int pixelRows;

    public int colors;

    public SnPSettings(int pixelRows, int colors) {
      this.colors = colors;
      this.pixelRows = pixelRows;
    }

    public String toString() {
      return shortClassName_dropNumberPrefix(this) + "(" + pixelRows + ", " + colors + ")";
    }

    public boolean equals(Object o) {
      if (!(o instanceof SnPSettings))
        return false;
      SnPSettings __1 = (SnPSettings) o;
      return pixelRows == __1.pixelRows && colors == __1.colors;
    }

    public int hashCode() {
      int h = -327917448;
      h = boostHashCombine(h, _hashCode(pixelRows));
      h = boostHashCombine(h, _hashCode(colors));
      return h;
    }

    public Object[] _fieldsToList() {
      return new Object[] { pixelRows, colors };
    }

    public SnPSettings() {
      pixelRows = 128;
      colors = 8;
    }

    public SnPSettings(BufferedImage image, int colors) {
      pixelRows = image.getHeight();
      this.colors = colors;
    }

    public SnPSettings cloneMe() {
      return shallowClone(this);
    }
  }

  static public class ScreenShotMeta implements IFieldsToList {

    public TimestampRange takenWhen;

    public Rect bounds;

    public BufferedImage image;

    public ScreenShotMeta() {
    }

    public ScreenShotMeta(TimestampRange takenWhen, Rect bounds, BufferedImage image) {
      this.image = image;
      this.bounds = bounds;
      this.takenWhen = takenWhen;
    }

    public String toString() {
      return shortClassName_dropNumberPrefix(this) + "(" + takenWhen + ", " + bounds + ", " + image + ")";
    }

    public Object[] _fieldsToList() {
      return new Object[] { takenWhen, bounds, image };
    }
  }

  static public class ScanlineBitMatrix extends AbstractMatrix<Boolean> implements Matrix<Boolean> {

    public ScanlineBitMatrix() {
    }

    public int bx1 = Integer.MAX_VALUE, by1, bx2, by2;

    public int pixels;

    public int[] scanlineData;

    public int[] scanlineStarts;

    public ScanlineBitMatrix(Matrix<Boolean> m) {
      super(m.getWidth(), m.getHeight());
      while (by1 < h && bitMatrixRowEmpty(m, by1)) by1++;
      by2 = h;
      while (by2 > by1 && bitMatrixRowEmpty(m, by2 - 1)) by2--;
      int ptr = 0, pixels = 0;
      scanlineStarts = new int[by2 - by1];
      IntBuffer scanlineData = new IntBuffer();
      lineLoop: for (int y = by1; y < by2; y++) {
        scanlineStarts[y - by1] = l(scanlineData);
        for (int x = 0; x < w; ) {
          while (!m.get(x, y)) if (++x >= w)
            continue lineLoop;
          int x2 = x + 1;
          while (x2 < w && m.get(x2, y)) ++x2;
          scanlineData.add(x);
          scanlineData.add(x2);
          pixels += x2 - x;
          if (x < bx1)
            bx1 = x;
          if (x2 > bx2)
            bx2 = x2;
          x = x2;
        }
      }
      this.scanlineData = scanlineData.toArray();
      this.pixels = pixels;
    }

    public Boolean get(int x, int y) {
      if (x < bx1 || y < by1 || x >= bx2 || y >= by2)
        return false;
      int ptr = scanlineStarts[y - by1];
      int end = y == by2 - 1 ? scanlineData.length : scanlineStarts[y - by1 + 1];
      while (ptr < end) {
        int x1 = scanlineData[ptr++];
        if (x < x1)
          return false;
        int x2 = scanlineData[ptr++];
        if (x < x2)
          return true;
      }
      return false;
    }

    public void set(int x, int y, Boolean a) {
      unimplemented();
    }

    public Rect boundingBoxOfTrueBits() {
      return bx1 >= bx2 ? null : rect(bx1, by1, bx2, by2);
    }

    public int nRuns() {
      return scanlineData.length / 2;
    }

    public IterableIterator<Rect> runs() {
      return new IterableIterator<Rect>() {

        public int y = 0, ptr = 0;

        public boolean hasNext() {
          return ptr < l(scanlineData);
        }

        public Rect next() {
          while (y < scanlineStarts.length - 1 && ptr >= scanlineStarts[y + 1]) ++y;
          int x1 = scanlineData[ptr++];
          int x2 = scanlineData[ptr++];
          return rect(x1, by1 + y, x2 - x1, 1);
        }
      };
    }

    public int pixelCount() {
      return pixels;
    }
  }

  static public class JFilePathLabel implements IFieldsToList {

    public File file;

    public JFilePathLabel() {
    }

    public JFilePathLabel(File file) {
      this.file = file;
    }

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

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

    transient public JLabel label;

    transient public JButton button;

    public JComponent visualize() {
      if (file == null)
        return jlabel("-");
      label = jlabel(f2s(file));
      button = jimageButtonScaledToWidth(16, "#1101292", "Show in file explorer", () -> showInExplorer());
      return layout();
    }

    public JComponent layout() {
      return jline(label, button);
    }

    public void showInExplorer() {
      {
        startThread(new Runnable() {

          public void run() {
            try {
              desktopOpen(dirOfFile(file));
            } catch (Exception __e) {
              throw rethrow(__e);
            }
          }

          public String toString() {
            return "desktopOpen(dirOfFile(file));";
          }
        });
      }
    }
  }

  static public class ReliableSingleThread implements Runnable {

    public boolean _isTransient() {
      return true;
    }

    public Object runnable;

    public String name = "Single Thread";

    public boolean cancelBeforeTrigger = false;

    public boolean waitBetweenCancelAndTrigger = false;

    public F0<AutoCloseable> enter;

    public int cancelTimeOut = 10000;

    public boolean trigger = false;

    public Thread thread;

    public WeakReference<Thread> threadBeingCancelled;

    public List<Runnable> inserts = syncL();

    public ReliableSingleThread(Object runnable) {
      this.runnable = runnable;
    }

    public void trigger() {
      go();
    }

    synchronized public void go() {
      if (cancelBeforeTrigger)
        cancelAndPossiblyWait();
      trigger = true;
      if (!running()) {
        AutoCloseable __1 = callF(enter);
        try {
          thread = startThread(name, new Runnable() {

            public void run() {
              try {
                AutoCloseable __2 = callF(enter);
                try {
                  _run();
                } finally {
                  _close(__2);
                }
              } catch (Exception __e) {
                throw rethrow(__e);
              }
            }

            public String toString() {
              return "temp callF(enter);\r\n        _run();";
            }
          });
        } finally {
          _close(__1);
        }
      }
    }

    public void run() {
      go();
    }

    public void get() {
      go();
    }

    synchronized public boolean running() {
      return thread != null;
    }

    public void triggerAndWait() {
      trigger();
      waitUntilDone();
    }

    public void waitUntilDone() {
      while (running()) sleep(1);
    }

    public void _run() {
      try {
        while (licensed()) {
          Thread oldThread;
          synchronized (this) {
            var currentInserts = syncGetAndClear(inserts);
            pcallFAll(currentInserts);
            if (!trigger) {
              thread = null;
              break;
            }
            oldThread = getWeakRef(threadBeingCancelled);
            trigger = false;
          }
          if (oldThread != null && oldThread != currentThread())
            oldThread.join(cancelTimeOut);
          pcallF(runnable);
        }
      } catch (Exception __e) {
        throw rethrow(__e);
      }
    }

    synchronized public void cancel() {
      if (thread == null)
        return;
      threadBeingCancelled = new WeakReference(thread);
      cancelAndInterruptThread(thread);
      thread = null;
    }

    public void cancelAndWait() {
      Thread _thread;
      synchronized (this) {
        if (thread == null)
          return;
        _thread = thread;
        threadBeingCancelled = new WeakReference(thread);
        thread = null;
      }
      cancelAndInterruptThread(_thread);
    }

    public void cancelAndTrigger() {
      cancelAndPossiblyWait();
      trigger();
    }

    synchronized public boolean triggered() {
      return trigger;
    }

    public void cleanMeUp() {
      cancel();
    }

    public ReliableSingleThread cancelBeforeTrigger() {
      cancelBeforeTrigger = true;
      return this;
    }

    public void cancelAndPossiblyWait() {
      if (waitBetweenCancelAndTrigger)
        cancel();
    }

    public void insert(Runnable r) {
      inserts.add(r);
      trigger();
    }
  }

  static public class JFastLogView_noWrap extends JComponent implements Scrollable {

    public List<String> lines = syncList();

    public boolean endsWithNewLine, verbose;

    public Dimension getPreferredScrollableViewportSize() {
      return getPreferredSize();
    }

    public int getScrollableUnitIncrement(Rectangle visibleRect, int orientation, int direction) {
      return 20;
    }

    public int getScrollableBlockIncrement(Rectangle visibleRect, int orientation, int direction) {
      return (direction == SwingConstants.HORIZONTAL ? visibleRect.width : visibleRect.height) * 5 / 6;
    }

    public boolean getScrollableTracksViewportWidth() {
      return false;
    }

    public boolean getScrollableTracksViewportHeight() {
      return false;
    }

    public void paint(Graphics g) {
      int w = getWidth(), h = getHeight();
      g.setColor(getBackground());
      g.fillRect(0, 0, w, h);
      g.setColor(getForeground());
      FontMetrics fm = componentFontMetrics(this);
      int fh = fm.getHeight();
      Rectangle clip = g.getClipBounds();
      int start, end;
      if (clip == null) {
        start = 0;
        end = l(lines);
      } else {
        start = max(0, clip.y / fh);
        end = min(l(lines), idiv_ceil(clip.y + clip.height, fh));
      }
      int y = fm.getAscent() + start * fh;
      for (int i = start; i < end; i++) {
        String s = get(lines, i);
        if (s != null)
          g.drawString(s, 0, y);
        y += fh;
      }
    }

    public Dimension getPreferredSize() {
      FontMetrics fm = componentFontMetrics(this);
      if (fm == null)
        return new Dimension(50, 50);
      int fh = fm.getHeight();
      int w = 0;
      for (int i = 0; i < l(lines); i++) {
        String s = get(lines, i);
        w = max(w, fm.stringWidth(unnull(s)));
      }
      return new Dimension(w, fh * l(lines));
    }

    public JFastLogView_noWrap() {
    }

    public JFastLogView_noWrap(String text) {
      setText(text);
    }

    {
      componentPopupMenuItem(this, "Copy full text", new Runnable() {

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

        public String toString() {
          return "copyFullText();";
        }
      });
    }

    public boolean setLines(Collection<String> lines) {
      List<String> newList = asSyncList(lines);
      if (eq(this.lines, newList))
        return false;
      this.lines = newList;
      _revalidate(this);
      return true;
    }

    public boolean setText(String text) {
      endsWithNewLine = endsWithNewLine(text);
      return setLines(lines(text));
    }

    public void append(String text) {
      if (nempty(text))
        setText(getText() + text);
    }

    public String getText() {
      return lines_rtrimIf(!endsWithNewLine, cloneList(lines));
    }

    public void copyFullText() {
      copyTextToClipboard(getText());
    }
  }

  static public class G22RecognizerScript extends G22LeftArrowScript {
  }

  static public class ScreenCamStream extends SourceTriggeredStream<BufferedImage> implements Steppable {

    final public ScreenCamStream setArea(Rect area) {
      return area(area);
    }

    public ScreenCamStream area(Rect area) {
      this.area = area;
      return this;
    }

    final public Rect getArea() {
      return area();
    }

    public Rect area() {
      return area;
    }

    volatile public Rect area = screenBounds(0);

    public boolean step() {
      if (ended())
        return false;
      catchError(() -> shootImpl());
      return true;
    }

    public long frameCount() {
      return elementCount();
    }

    public void shootImpl() {
      var img = shootScreenWithMeta(area).image;
      assertInstanceOf(ScreenShotMeta.class, getMetaSrc(img));
      newElement(img);
    }

    public void useScreen(int iScreen) {
      area = screenBounds_safe(iScreen);
    }
  }

  static public class BackgroundProcessesUI {

    public Set<Entry> processes = setWithNotify(syncLinkedHashSet(), () -> updateCount());

    public SimpleLiveValue<Integer> lvCount = new SimpleLiveValue<Integer>(Integer.class, 0);

    static public class Entry implements IFieldsToList {

      static final public String _fieldOrder = "name menuItem";

      public String name;

      public Entry() {
      }

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

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

      public int hashCode() {
        int h = 67115090;
        h = boostHashCombine(h, _hashCode(name));
        return h;
      }

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

      final public Entry setMenuItem(JMenuItem menuItem) {
        return menuItem(menuItem);
      }

      public Entry menuItem(JMenuItem menuItem) {
        this.menuItem = menuItem;
        return this;
      }

      final public JMenuItem getMenuItem() {
        return menuItem();
      }

      public JMenuItem menuItem() {
        return menuItem;
      }

      public JMenuItem menuItem;

      public String toString() {
        return name;
      }
    }

    public JLabel shortLabel() {
      var lbl = bindToolTipToTransformedLiveValue(n -> makeToolTip(), lvCount, simpleTransformedLiveValueLabel(n -> n2(n), lvCount));
      onMouseDown_anyButton(lbl, e -> {
        var l = cloneList(processes);
        JPopupMenu menu = new JPopupMenu();
        int n = componentCount(menu);
        for (Entry a : l) addMenuItem(menu, processToMenuItem(a));
        if (componentCount(menu) != n) {
          var border = jRaisedSectionBorder("Background Processes");
          setBorder(menu, border);
          showPopupMenu(menu, e);
          var size = menu.getSize();
          var borderSize = dimensionPlus(10, 0, border.getMinimumSize(menu));
          printVars("size", size, "borderSize", borderSize);
          menu.setPopupSize(maxDimension(size, borderSize));
        }
      });
      return lbl;
    }

    public void add(Entry process) {
      processes.add(process);
    }

    public void remove(Entry process) {
      processes.remove(process);
    }

    public void addOrRemove(boolean add, Entry process) {
      if (add)
        add(process);
      else
        remove(process);
    }

    public AutoCloseable tempAdd(Entry process) {
      if (process == null)
        return null;
      return loadableUtils.utils.tempAdd(processes, process);
    }

    public void updateCount() {
      lvCount.set(l(processes));
    }

    public String makeToolTip() {
      var l = cloneList(processes);
      return empty(l) ? "No background processes" : n2(l, "background process", "background processes") + ": " + joinWithComma(processes);
    }

    transient public IF1<Entry, JMenuItem> processToMenuItem;

    public JMenuItem processToMenuItem(Entry process) {
      return processToMenuItem != null ? processToMenuItem.get(process) : processToMenuItem_base(process);
    }

    final public JMenuItem processToMenuItem_fallback(IF1<Entry, JMenuItem> _f, Entry process) {
      return _f != null ? _f.get(process) : processToMenuItem_base(process);
    }

    public JMenuItem processToMenuItem_base(Entry process) {
      return process.getMenuItem();
    }
  }

  static public class FunctionTimings<A> {

    public Map<A, Average> data = syncMap();

    final public void time(A function, Runnable r) {
      dO(function, r);
    }

    public void dO(A function, Runnable r) {
      if (r == null)
        return;
      Average avg = syncMapGetOrCreate(data, function, () -> new Average());
      long time = nanoTime();
      try {
        r.run();
      } finally {
        time = nanoTime() - time;
        avg.add(time);
      }
    }

    public Map<A, Average> get() {
      return cloneMap(data);
    }

    final public void clear() {
      reset();
    }

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

    public String render() {
      return lines(ciSorted(map(get(), (f, avg) -> functionToString(f) + ": " + n2(iround(nsToMicroseconds(avg.get()))) + " " + microSymbol() + "s (" + n2(iround(avg.n())) + ")")));
    }

    public String functionToString(A f) {
      return firstToUpper(str(f));
    }
  }

  static public class ConceptFieldIndex<A extends Concept, Val> extends ConceptFieldIndexBase<A, Val> {

    public ConceptFieldIndex(Class<A> cc, String field) {
      super(cc, field);
    }

    public ConceptFieldIndex(Concepts concepts, Class<A> cc, String field) {
      super(concepts, cc, field);
    }

    public void init() {
      valueToObject = new MultiSetMap();
    }

    public void register() {
      concepts.addFieldIndex(cc, field, this);
    }
  }

  abstract static public class AbstractLayoutManager implements LayoutManager {

    public Dimension preferredSize = new Dimension(100, 100);

    public Dimension minimumSize = new Dimension(10, 10);

    public void addLayoutComponent(String name, Component comp) {
    }

    public void removeLayoutComponent(Component comp) {
    }

    public Dimension preferredLayoutSize(Container parent) {
      layoutContainer(parent);
      return preferredSize;
    }

    public Dimension minimumLayoutSize(Container parent) {
      return minimumSize;
    }
  }

  static public class JLeftArrowScriptIDE implements Swingable {

    final public JLeftArrowScriptIDE setLvScript(SimpleLiveValue<String> lvScript) {
      return lvScript(lvScript);
    }

    public JLeftArrowScriptIDE lvScript(SimpleLiveValue<String> lvScript) {
      this.lvScript = lvScript;
      return this;
    }

    final public SimpleLiveValue<String> getLvScript() {
      return lvScript();
    }

    public SimpleLiveValue<String> lvScript() {
      return lvScript;
    }

    public SimpleLiveValue<String> lvScript = stringLiveValue();

    final public JLeftArrowScriptIDE setSectionTitle(String sectionTitle) {
      return sectionTitle(sectionTitle);
    }

    public JLeftArrowScriptIDE sectionTitle(String sectionTitle) {
      this.sectionTitle = sectionTitle;
      return this;
    }

    final public String getSectionTitle() {
      return sectionTitle();
    }

    public String sectionTitle() {
      return sectionTitle;
    }

    public String sectionTitle = "Left arrow script";

    static public String helpText = "Gazelle 22 \"Left Arrow Script\"\r\n------------------------------\r\n\r\n\"Left arrow script\" is one of Gazelle 22's two scripting languages. It is the powerful one of the two. It can do anything Java can do except for defining classes or lambdas.\r\n\r\n-Usually, you write one command per line\r\n-Each command contains at most one action and at most one assignment\r\n-The language is case-sensitive\r\n-You can add comments like in Java with /* */ or //\r\n-You can write multiple commands in one line by separating them with a semicolon\r\n-Arguments to functions are separated by spaces\r\n-You can use integer and string literals like in Java\r\n-You can use true, false and null\r\n\r\nIt's called \"left arrow script\" because the left arrow (variable assignment) is its only actual operator (not counting ; and {}).\r\n\r\n\r\nOperations\r\n----------\r\n\r\nYou can call any global function defined in Gazelle. Example:\r\n\r\n  infoBox \"hello\"   // show a popup with the text \"hello\"\r\n  \r\nYou can assign the result of a function call to a variable:\r\n\r\n  time <- tsNow     // get current time as a Timestamp object\r\n  infoBox time      // show as popup\r\n  \r\nNote that this script requires 2 lines because only one operation is allowed per command.\r\n  \r\nVariables can be overwritten and don't have to be declared.\r\n\r\n\r\nCreating objects\r\n----------------\r\n\r\nYou can create an instance of any Java class and call methods on the object:\r\n\r\n  list <- new ArrayList\r\n  list add \"hello\"\r\n  list add \"world\"\r\n  infoBox list       // shows [hello, world]\r\n  \r\n(Currently you can also say \"list <- ArrayList\", but this is ambiguous and may be removed in a future version.)\r\n  \r\nYou can pass parameters to the constructor:\r\n\r\n  pair <- new Pair \"hello\" \"world\"\r\n  infoBox pair      // shows <hello, world>\r\n  \r\n\r\nJava operators (+, * etc)\r\n-------------------------\r\n  \r\nJava operators can't be used directly but we have functions that do the same thing (if we don't, we'll add them):\r\n\r\n  x <- plus 1 2\r\n  infoBox x\r\n\r\n\r\nFunction definitions\r\n--------------------\r\n\r\nYou can define functions in your script, with arguments. The function can return a value (which is the result of the last command in the function).\r\n\r\n  def doubleMe x { mul x 2 }\r\n\r\n  x <- doubleMe 5\r\n  infoBox x        // shows 10\r\n";

    transient public CompileResult compileResult;

    transient public RSyntaxTextAreaWithSearch taScript;

    transient public Q compileQ = new Q();

    transient public JLabel lblCompileResult;

    transient public JButton btnRun;

    transient public SingleComponentPanel scpResult;

    transient public LeftArrowCompletionProvider completionProvider;

    transient public AutoCompletion autoComplete;

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

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

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

    public G22Utils g22utils() {
      return g22utils;
    }

    transient public G22Utils g22utils;

    final public JLeftArrowScriptIDE setScriptTimeout(double scriptTimeout) {
      return scriptTimeout(scriptTimeout);
    }

    public JLeftArrowScriptIDE scriptTimeout(double scriptTimeout) {
      this.scriptTimeout = scriptTimeout;
      return this;
    }

    final public double getScriptTimeout() {
      return scriptTimeout();
    }

    public double scriptTimeout() {
      return scriptTimeout;
    }

    public double scriptTimeout = 10.0;

    public class LeftArrowCompletionProvider extends DefaultCompletionProvider {

      @Override
      public List<Completion> getCompletionsImpl(JTextComponent comp) {
        try {
          print("getCompletionsImpl");
          String text = getText(comp);
          GazelleV_LeftArrowScriptParser parser = makeParser();
          LeftArrowScriptAutoCompleter completer = new LeftArrowScriptAutoCompleter(g22utils, parser);
          enableScaffolding(completer);
          completer.seek(text, getCaretPosition(comp));
          return map(completer.searcher().withScores(), completion -> {
            BasicCompletion c = new BasicCompletion(this, completion.get());
            c.setRelevance((int) completion.score());
            return c;
          });
        } catch (Throwable e) {
          printStackTrace(e);
          return ll();
        }
      }
    }

    public JComponent visualize() {
      taScript = liveValueRSyntaxTextArea_bothWays(lvScript);
      awtCalcEvery(taScript.textArea(), 1.0, () -> compileQ.add(new Runnable() {

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

        public String toString() {
          return "compile();";
        }
      }));
      {
        swing(() -> {
          completionProvider = new LeftArrowCompletionProvider();
          completionProvider.setAutoActivationRules(true, " ");
          autoComplete = new AutoCompletion(completionProvider);
          autoComplete.setAutoCompleteSingleChoices(false);
          autoComplete.setAutoActivationEnabled(true);
          autoComplete.setAutoActivationDelay(2000);
          autoComplete.install(taScript.textArea);
          print("Auto-complete installed on " + taScript.textArea);
        });
      }
      JComponent vis = jCenteredSection(sectionTitle, centerAndSouthWithMargin(taScript.visualize(), centerAndEastWithMargin(jBorderlessHigherScrollPane(lblCompileResult = jlabel()), centerAndSouth(jpanel(), jline(btnRun = jbutton("Run", runnableThread(new Runnable() {

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

        public String toString() {
          return "runScript();";
        }
      })), jPopDownButton_noText("Show Scripting Help", runnableThread(new Runnable() {

        public void run() {
          try {
            showTextWordWrapped("Gazelle 'Left arrow script' Help", helpText);
          } catch (Exception __e) {
            throw rethrow(__e);
          }
        }

        public String toString() {
          return "showTextWordWrapped(\"Gazelle 'Left arrow script' Help\", helpText)";
        }
      }), "Show Global Class Names", runnableThread(new Runnable() {

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

        public String toString() {
          return "showGlobalClassNames();";
        }
      })))))));
      if (scpResult != null)
        vis = jhsplit(jCenteredSection("Image will show here", scpResult), vis);
      return vis;
    }

    public boolean visible() {
      return isShowing(lblCompileResult);
    }

    public void compile() {
      var script = lvScript.get();
      var result = compileResult;
      if (result == null || !eq(result.script, script)) {
        try {
          result = new CompileResult();
          result.script = script;
          result.parser = makeParser();
          result.parsedScript = result.parser.parse(result.script);
          print(result.parsedScript);
        } catch (Throwable e) {
          print(e);
          result.compileError = e;
        }
        compileResult = result;
        setText(lblCompileResult, compileResult);
        updateRunButtonState();
      }
    }

    public void updateRunButtonState() {
      setEnabled(btnRun, runButtonShouldBeEnabled());
    }

    transient public IF0<Boolean> runButtonShouldBeEnabled;

    public boolean runButtonShouldBeEnabled() {
      return runButtonShouldBeEnabled != null ? runButtonShouldBeEnabled.get() : runButtonShouldBeEnabled_base();
    }

    final public boolean runButtonShouldBeEnabled_fallback(IF0<Boolean> _f) {
      return _f != null ? _f.get() : runButtonShouldBeEnabled_base();
    }

    public boolean runButtonShouldBeEnabled_base() {
      return compileResult != null && compileResult.runnable();
    }

    public CompileResult freshCompileResult() {
      runInQAndWait(compileQ, new Runnable() {

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

        public String toString() {
          return "compile();";
        }
      });
      return compileResult;
    }

    public GazelleV_LeftArrowScript.Script parsedScript() {
      return freshCompileResult().parsedScript;
    }

    transient public Runnable runScript;

    public void runScript() {
      if (runScript != null)
        runScript.run();
      else
        runScript_base();
    }

    final public void runScript_fallback(Runnable _f) {
      if (_f != null)
        _f.run();
      else
        runScript_base();
    }

    public void runScript_base() {
      var result = freshCompileResult();
      if (result.parsedScript != null) {
        result.result = okOrError(() -> callCompiledObjectWithTimeout(result.parsedScript));
        showScriptResult(result.result);
      }
    }

    public void showScriptResult(OKOrError result) {
      if (result.isOK())
        setStatus(shorten(g22utils.stringify(result.get())));
      else
        setStatus(exceptionToStringShorter_dontDropOuterExceptions(result.error()));
    }

    public class CompileResult {

      public String script;

      public GazelleV_LeftArrowScriptParser parser;

      public Throwable compileError;

      public GazelleV_LeftArrowScript.Script parsedScript;

      public OKOrError result;

      public String toString() {
        return compileError != null ? exceptionToStringShorter_dontDropOuterExceptions(compileError) : "Compiled OK";
      }

      public boolean runnable() {
        return parsedScript != null;
      }
    }

    public void setStatus(String status) {
      setText(lblCompileResult, status);
    }

    transient public IVF1<GazelleV_LeftArrowScriptParser> modifyParser;

    public void modifyParser(GazelleV_LeftArrowScriptParser parser) {
      if (modifyParser != null)
        modifyParser.get(parser);
      else
        modifyParser_base(parser);
    }

    final public void modifyParser_fallback(IVF1<GazelleV_LeftArrowScriptParser> _f, GazelleV_LeftArrowScriptParser parser) {
      if (_f != null)
        _f.get(parser);
      else
        modifyParser_base(parser);
    }

    public void modifyParser_base(GazelleV_LeftArrowScriptParser parser) {
    }

    public void showStatus(String status) {
      setText(lblCompileResult, status);
    }

    public void showRuntimeError(Throwable e) {
      showStatus(exceptionToStringShorter(e));
    }

    public void withResultPanel() {
      if (scpResult == null)
        scpResult = singleComponentPanel();
    }

    transient public IF0<VarContext> makeVarContextForExecution;

    public VarContext makeVarContextForExecution() {
      return makeVarContextForExecution != null ? makeVarContextForExecution.get() : makeVarContextForExecution_base();
    }

    final public VarContext makeVarContextForExecution_fallback(IF0<VarContext> _f) {
      return _f != null ? _f.get() : makeVarContextForExecution_base();
    }

    public VarContext makeVarContextForExecution_base() {
      return new VarContext();
    }

    public Object callCompiledObjectWithTimeout(GazelleV_LeftArrowScript.Script object) {
      return callCompiledObjectWithTimeout(scriptTimeout, object);
    }

    public Object callCompiledObjectWithTimeout(double timeoutSeconds, GazelleV_LeftArrowScript.Script object) {
      return callCompiledObjectWithTimeout(scriptTimeout, object, makeVarContextForExecution());
    }

    public Object callCompiledObjectWithTimeout(GazelleV_LeftArrowScript.Script object, VarContext ctx) {
      return callCompiledObjectWithTimeout(scriptTimeout, object, ctx);
    }

    public Object callCompiledObjectWithTimeout(double timeoutSeconds, GazelleV_LeftArrowScript.Script object, VarContext ctx) {
      Object result = evalWithTimeoutOrTypedException(timeoutSeconds, () -> object.get(ctx));
      if (result instanceof BufferedImage) {
        if (scpResult != null)
          scpResult.set(jscroll_centered_borderless(g22utils.stdImageSurface((BufferedImage) result)));
      }
      return result;
    }

    public GazelleV_LeftArrowScriptParser makeParser() {
      var parser = g22utils.leftArrowParser();
      modifyParser(parser);
      print("Function containers: " + parser.functionContainers);
      return parser;
    }

    public void showGlobalClassNames() {
      showText("Global Class Names", pnlToString(toCIMap(makeParser().globalClassNames())));
    }
  }

  static public interface Hasher<A> {

    public int hashCode(A a);

    public boolean equals(A a, A b);
  }

  static abstract public class CloseableIterableIterator<A> extends IterableIterator<A> implements AutoCloseable {

    public void close() throws Exception {
    }
  }

  static public class Gazelle22_ImageToRegions {

    public BufferedImage inputImage;

    public Decolorizer decolorizer;

    public BWIntegralImage ii;

    public SnPSettings snpSettings;

    public BWImage posterized;

    public FastRegions_BWImage regions;

    public Map<IImageRegion<BWImage>, Double> scoredRegions;

    public boolean wasRun = false;

    public FunctionTimings<String> timings;

    public Gazelle22_ImageToRegions(FunctionTimings<String> timings, BufferedImage inputImage, SnPSettings snpSettings) {
      this.snpSettings = snpSettings;
      this.inputImage = inputImage;
      this.timings = timings;
    }

    public void run() {
      try {
        wasRun = true;
        timings.dO(decolorizer != null ? "bwIntegralImage w/decolorizer" : "bwIntegralImage", () -> ii = bwIntegralImage_withMeta(inputImage, decolorizer));
        timings.dO("scaleAndPosterize", () -> posterized = scaleAndPosterize(ii, snpSettings));
        regions = new FastRegions_BWImage(posterized);
        regions.collectBounds();
        timings.dO("Regions", regions);
      } catch (Exception __e) {
        throw rethrow(__e);
      }
    }

    public ScreenShotMeta screenShotMeta() {
      return optCast(ScreenShotMeta.class, getMetaSrc(inputImage));
    }

    public Pt coordinatesFromScreen(Pt p) {
      var meta = screenShotMeta();
      if (meta == null)
        return null;
      var r = meta.bounds;
      if (!r.contains(p))
        return null;
      p = translatePt(p, -r.x, -r.y);
      return scalePt(p, doubleRatio(snpSettings.pixelRows, r.h));
    }

    public Pt coordinatesToScreen(Pt p) {
      var meta = screenShotMeta();
      if (meta == null)
        return null;
      var r = meta.bounds;
      return translatePt(r.x, r.y, scalePt(p, doubleRatio(r.h, snpSettings.pixelRows)));
    }

    public FastRegions_BWImage regions() {
      if (!wasRun)
        run();
      return regions;
    }
  }

  static public class JGallery implements Swingable {

    public boolean _isTransient() {
      return true;
    }

    public List<File> files;

    public DynamicHStack buttons = makeNiceButtons();

    public ButtonImageLoader imageLoader = new ButtonImageLoader(buttons);

    public void setImageFiles(List<File> files) {
      if (eq(this.files, files))
        return;
      this.files = files;
      printVars("JGallery.setImageFiles", files);
      List<TextImageAction> l = filesForNiceButtons(files, __1 -> openImage(__1));
      replaceNiceButtons(buttons, l);
      {
        if (imageLoader != null)
          imageLoader.update();
      }
    }

    public JComponent visualize() {
      return jHigherScrollPane(jfullcenter(buttons));
    }

    transient public IVF1<File> openImage;

    public void openImage(File f) {
      if (openImage != null)
        openImage.get(f);
      else
        openImage_base(f);
    }

    final public void openImage_fallback(IVF1<File> _f, File f) {
      if (_f != null)
        _f.get(f);
      else
        openImage_base(f);
    }

    public void openImage_base(File f) {
      showImage(f);
    }
  }

  static public interface IFieldsToList {

    public Object[] _fieldsToList();
  }

  static public interface IF2<A, B, C> {

    public C get(A a, B b);
  }

  static public class G22DatabasesPanel {

    public G22Utils g22utils;

    public Concepts concepts;

    public JObjectTable<GazelleDB> table;

    public FileWatchService dirWatcher;

    public ReliableSingleThread rstUpdate = new ReliableSingleThread(new Runnable() {

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

      public String toString() {
        return "_updateTable();";
      }
    });

    public G22DatabasesPanel(G22Utils g22utils, Concepts concepts) {
      this.concepts = concepts;
      this.g22utils = g22utils;
    }

    public class GazelleDB implements IFieldsToList {

      public String name;

      public File dir;

      public GazelleDB() {
      }

      public GazelleDB(String name, File dir) {
        this.dir = dir;
        this.name = name;
      }

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

      public boolean equals(Object o) {
        if (!(o instanceof GazelleDB))
          return false;
        GazelleDB __0 = (GazelleDB) o;
        return eq(name, __0.name) && eq(dir, __0.dir);
      }

      public int hashCode() {
        int h = 1669530526;
        h = boostHashCombine(h, _hashCode(name));
        h = boostHashCombine(h, _hashCode(dir));
        return h;
      }

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

      public Boolean loaded_cache;

      public boolean loaded() {
        if (loaded_cache == null)
          loaded_cache = loaded_load();
        return loaded_cache;
      }

      public Boolean loaded_load() {
        return sameFile(dir, concepts.conceptsDir());
      }
    }

    public JComponent visualize() {
      table = swing(() -> new JObjectTable());
      table.defaultAction(runnableToIVF1(runnableThread(new Runnable() {

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

        public String toString() {
          return "switchDB();";
        }
      })));
      table.itemToMap = db -> litorderedmap("Name", db.name, "Directory", f2s(db.dir), "Loaded", db.loaded() ? "Yes" : "No");
      var tbl = table.visualize();
      bindToComponent(tbl, () -> {
        dirWatcher = new FileWatchService();
        dirWatcher.addNonRecursiveListener(g22utils.databasesMotherDir(), dir -> rstUpdate.get());
        rstUpdate.get();
      }, () -> {
        {
          cleanUp(dirWatcher);
          dirWatcher = null;
        }
      });
      return withTopAndBottomMargin(jCenteredRaisedSection("Gazelle Databases", northAndCenterWithMargins(jline(toolTip("Create a new Gazelle database", jbutton("New Gazelle database...", runnableThread(new Runnable() {

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

        public String toString() {
          return "newDatabase();";
        }
      })))), centerAndEastWithMargins(tbl, vstackWithSpacing_fixed(tableDependentButton(table.table, "Switch to database", runnableThread(new Runnable() {

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

        public String toString() {
          return "switchDB();";
        }
      })), tableDependentButton(table.table, "Delete database (TODO)"), tableDependentButton(table.table, "Browse files", runnableThread(new Runnable() {

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

        public String toString() {
          return "browse();";
        }
      })))))));
    }

    public void newDatabase() {
      AutoCloseable __2 = g22utils.enter();
      try {
        var tf = jtextfield();
        var lblDir = jlabel(" ");
        var lblStatus = jlabel(" ");
        var button = jbutton("Create database", new Runnable() {

          public void run() {
            try {
              AutoCloseable __3 = g22utils.enter();
              try {
                String name = trim(tf.getText());
                File dir = newFile(g22utils.databasesMotherDir(), name);
                createEmptyConceptsFileInDir(dir);
                disposeFrame(tf);
              } finally {
                _close(__3);
              }
            } catch (Exception __e) {
              throw rethrow(__e);
            }
          }

          public String toString() {
            return "temp g22utils.enter();\r\n      \r\n      String name = trim(tf.getText());\r\n    ...";
          }
        });
        disableButton(button);
        onEnter(tf, button);
        onChange(tf, new Runnable() {

          public void run() {
            try {
              String name = trim(tf.getText());
              boolean ok = false;
              String status = " ", path = " ";
              if (isValidFileName(name)) {
                File dir = newFile(g22utils.databasesMotherDir(), name);
                path = f2s(dir);
                if (dirExists(dir))
                  status = "A database with that name exists";
                else
                  ok = true;
              } else if (!empty(name))
                status = "Database name must be a valid file name";
              setEnabled(button, ok);
              setText(lblStatus, status);
              setText(lblDir, path);
            } catch (Exception __e) {
              throw rethrow(__e);
            }
          }

          public String toString() {
            return "String name = trim(tf.getText());\r\n      boolean ok;\r\n      String status = \"...";
          }
        });
        showForm_makeFrame("New Gazelle Database", vstackWithSpacing(withLabel("Name for new database", tf), lblDir, lblStatus, button));
      } finally {
        _close(__2);
      }
    }

    public void _updateTable() {
      List<GazelleDB> dbs = new ArrayList();
      dbs.add(new GazelleDB("Legacy DB", programDir()));
      for (File dir : listDirsContainingFileNamed(g22utils.databasesMotherDir(), "concepts.structure.gz")) dbs.add(new GazelleDB(fileName(dir), dir));
      table.setList(dbs);
    }

    public void browse() {
      desktopOpen(table.selected().dir);
    }

    public void switchDB() {
      g22utils.masterStuff().switchDatabase(table.selected().dir);
    }
  }

  static public class GazelleV_LeftArrowScript {

    abstract static public class Base implements IHasTokenRangeWithSrc {

      public TokenRangeWithSrc src;

      public void setTokenRangeWithSrc(TokenRangeWithSrc src) {
        this.src = src;
      }

      public TokenRangeWithSrc tokenRangeWithSrc() {
        return src;
      }

      public RuntimeException rethrowWithSrc(Throwable e) {
        if (src != null)
          throw rethrowAndAppendToMessage(e, squareBracketed(str(src)));
        else
          throw rethrow(e);
      }
    }

    public interface Evaluable {

      public default Object get() {
        return get(new VarContext());
      }

      public Object get(VarContext ctx);

      public default LASValueDescriptor returnType() {
        return null;
      }

      public default Evaluable optimize() {
        return this;
      }
    }

    abstract static public class BaseEvaluable extends Base implements Evaluable {

      final public BaseEvaluable setReturnType(LASValueDescriptor returnType) {
        return returnType(returnType);
      }

      public BaseEvaluable returnType(LASValueDescriptor returnType) {
        this.returnType = returnType;
        return this;
      }

      final public LASValueDescriptor getReturnType() {
        return returnType();
      }

      public LASValueDescriptor returnType() {
        return returnType;
      }

      public LASValueDescriptor returnType;
    }

    static public AtomicLong scriptIDCounter = new AtomicLong();

    static public long scriptID() {
      return incAtomicLong(scriptIDCounter);
    }

    static public class Script implements Evaluable {

      public long id = scriptID();

      public Map<String, FunctionDef> functionDefs;

      public Evaluable[] steps;

      public Object get(VarContext ctx) {
        Object result = null;
        for (var step : steps) {
          ping();
          result = step.get(ctx);
          var exiting = ctx.exitFromScript;
          if (exiting != null) {
            if (exiting == this)
              ctx.exitFromScript = null;
            break;
          }
        }
        return result;
      }

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

      public String toString() {
        return "Script " + n2(id);
      }

      public FunctionDef getFunction(String name) {
        return mapGet(functionDefs, name);
      }
    }

    static public class FunctionDef extends Base implements IFieldsToList {

      public String name;

      public List<String> args;

      public Evaluable body;

      public FunctionDef() {
      }

      public FunctionDef(String name, List<String> args, Evaluable body) {
        this.body = body;
        this.args = args;
        this.name = name;
      }

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

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

      public Object call(VarContext ctx, Object... args) {
        var ctx2 = new VarContext(ctx);
        int n = min(l(args), l(this.args));
        for (int i = 0; i < n; i++) ctx2.put(this.args.get(i), args[i]);
        return body.get(ctx2);
      }
    }

    static public class Assignment extends Base implements Evaluable, IFieldsToList {

      public String var;

      public Evaluable expression;

      public Assignment() {
      }

      public Assignment(String var, Evaluable expression) {
        this.expression = expression;
        this.var = var;
      }

      public Object[] _fieldsToList() {
        return new Object[] { var, expression };
      }

      public Object get(VarContext ctx) {
        Object o = expression.get(ctx);
        ctx.set(var, o);
        return o;
      }

      public String toString() {
        return var + " <- " + expression;
      }
    }

    static public class NewObject extends Base implements Evaluable {

      public NewObject() {
      }

      public Class c;

      public List<Evaluable> args;

      public NewObject(Class c) {
        this.c = c;
      }

      public NewObject(Class c, List<Evaluable> args) {
        this.args = args;
        this.c = c;
      }

      public Object get(VarContext ctx) {
        return callConstructor(c, mapToArray(args, arg -> arg.get(ctx)));
      }

      public String toString() {
        return "new " + formatFunctionCall(className(c), args);
      }
    }

    static public class CallFunction extends Base implements Evaluable, IFieldsToList {

      public FunctionDef f;

      public List<Evaluable> args;

      public CallFunction() {
      }

      public CallFunction(FunctionDef f, List<Evaluable> args) {
        this.args = args;
        this.f = f;
      }

      public Object[] _fieldsToList() {
        return new Object[] { f, args };
      }

      public Object get(VarContext ctx) {
        return f.call(ctx, mapToArray(args, a -> a.get(ctx)));
      }

      public String toString() {
        return formatFunctionCall(f.name, args);
      }
    }

    static public class GetVar extends BaseEvaluable implements IFieldsToList {

      public String var;

      public GetVar() {
      }

      public GetVar(String var) {
        this.var = var;
      }

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

      public Object get(VarContext ctx) {
        return ctx.get(var);
      }

      public String toString() {
        return var;
      }
    }

    static public class Const extends Base implements Evaluable, IFieldsToList {

      public Object value;

      public Const() {
      }

      public Const(Object value) {
        this.value = value;
      }

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

      public Object get(VarContext ctx) {
        return value;
      }

      public String toString() {
        return strOrClassName(value);
      }

      public LASValueDescriptor returnType() {
        return new LASValueDescriptor.KnownValue(value);
      }
    }

    static public class GetStaticField extends Base implements Evaluable, IFieldsToList {

      public Field field;

      public GetStaticField() {
      }

      public GetStaticField(Field field) {
        this.field = field;
      }

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

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

      public Object get(VarContext ctx) {
        try {
          return field.get(null);
        } catch (Exception __e) {
          throw rethrow(__e);
        }
      }
    }

    static public class CallMethodOrGetField extends Base implements Evaluable, IFieldsToList {

      public Evaluable target;

      public String name;

      public CallMethodOrGetField() {
      }

      public CallMethodOrGetField(Evaluable target, String name) {
        this.name = name;
        this.target = target;
      }

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

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

      public Object get(VarContext ctx) {
        try {
          Object object = target.get(ctx);
          if (object == null)
            return null;
          if (canCallWithVarargs(object, name))
            return call(object, name);
          return _get(object, name);
        } catch (Throwable e) {
          throw rethrowWithSrc(e);
        }
      }
    }

    static public class ThrowMethodNotFoundException extends Base implements Evaluable, IFieldsToList {

      public CallMethod instruction;

      public ThrowMethodNotFoundException() {
      }

      public ThrowMethodNotFoundException(CallMethod instruction) {
        this.instruction = instruction;
      }

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

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

      public int hashCode() {
        int h = -1067891687;
        h = boostHashCombine(h, _hashCode(instruction));
        return h;
      }

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

      public Object get(VarContext ctx) {
        throw fail("Method not found: " + instruction);
      }
    }

    static public class ThrowNullPointerException extends Base implements Evaluable, IFieldsToList {

      public CallMethod instruction;

      public ThrowNullPointerException() {
      }

      public ThrowNullPointerException(CallMethod instruction) {
        this.instruction = instruction;
      }

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

      public boolean equals(Object o) {
        if (!(o instanceof ThrowNullPointerException))
          return false;
        ThrowNullPointerException __2 = (ThrowNullPointerException) o;
        return eq(instruction, __2.instruction);
      }

      public int hashCode() {
        int h = -399028705;
        h = boostHashCombine(h, _hashCode(instruction));
        return h;
      }

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

      public Object get(VarContext ctx) {
        throw fail("Null pointer exception: " + instruction);
      }
    }

    static public class CallMethod extends Base implements Evaluable, IFieldsToList {

      static final public String _fieldOrder = "target methodName args";

      public Evaluable target;

      public String methodName;

      public List<Evaluable> args;

      public CallMethod() {
      }

      public CallMethod(Evaluable target, String methodName, List<Evaluable> args) {
        this.args = args;
        this.methodName = methodName;
        this.target = target;
      }

      public boolean equals(Object o) {
        if (!(o instanceof CallMethod))
          return false;
        CallMethod __3 = (CallMethod) o;
        return eq(target, __3.target) && eq(methodName, __3.methodName) && eq(args, __3.args);
      }

      public int hashCode() {
        int h = -898542337;
        h = boostHashCombine(h, _hashCode(target));
        h = boostHashCombine(h, _hashCode(methodName));
        h = boostHashCombine(h, _hashCode(args));
        return h;
      }

      public Object[] _fieldsToList() {
        return new Object[] { target, methodName, args };
      }

      public Object get(VarContext ctx) {
        return call(target.get(ctx), methodName, mapToArray(args, arg -> arg.get(ctx)));
      }

      public String toString() {
        return target + "." + formatFunctionCall(methodName, args);
      }

      public Evaluable optimize() {
        var targetType = target.returnType();
        if (targetType.knownValue()) {
          Object o = targetType.value();
          if (o == null)
            return new ThrowNullPointerException(this);
          Class[] argTypes = new Class[l(args)];
          for (int i = 0; i < l(args); i++) {
            var type = args.get(i).returnType();
            if (!type.javaClassIsExact())
              return this;
            argTypes[i] = type.javaClass();
          }
          var method = findMethod_precise_onTypes(o, methodName, argTypes);
          if (method == null)
            return new ThrowMethodNotFoundException(this);
          return new DirectMethodCallOnKnownTarget(o instanceof Class ? null : o, method, args);
        }
        return this;
      }
    }

    static public class DirectMethodCallOnKnownTarget extends Base implements Evaluable, IFieldsToList {

      static final public String _fieldOrder = "target method args";

      public Object target;

      public Method method;

      public List<Evaluable> args;

      public DirectMethodCallOnKnownTarget() {
      }

      public DirectMethodCallOnKnownTarget(Object target, Method method, List<Evaluable> args) {
        this.args = args;
        this.method = method;
        this.target = target;
      }

      public boolean equals(Object o) {
        if (!(o instanceof DirectMethodCallOnKnownTarget))
          return false;
        DirectMethodCallOnKnownTarget __4 = (DirectMethodCallOnKnownTarget) o;
        return eq(target, __4.target) && eq(method, __4.method) && eq(args, __4.args);
      }

      public int hashCode() {
        int h = -1591792531;
        h = boostHashCombine(h, _hashCode(target));
        h = boostHashCombine(h, _hashCode(method));
        h = boostHashCombine(h, _hashCode(args));
        return h;
      }

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

      public Object get(VarContext ctx) {
        return invokeMethod(method, target, mapToArray(args, arg -> arg.get(ctx)));
      }

      public String toString() {
        return (target == null ? "" : target + ".") + formatFunctionCall(str(method), args);
      }

      public LASValueDescriptor returnType() {
        return LASValueDescriptor.fromClass(method.getReturnType());
      }
    }

    static public class While extends Base implements Evaluable, IFieldsToList {

      static final public String _fieldOrder = "condition body";

      public Evaluable condition;

      public Evaluable body;

      public While() {
      }

      public While(Evaluable condition, Evaluable body) {
        this.body = body;
        this.condition = condition;
      }

      public String toString() {
        return shortClassName_dropNumberPrefix(this) + "(" + condition + ", " + body + ")";
      }

      public boolean equals(Object o) {
        if (!(o instanceof While))
          return false;
        While __5 = (While) o;
        return eq(condition, __5.condition) && eq(body, __5.body);
      }

      public int hashCode() {
        int h = 83548945;
        h = boostHashCombine(h, _hashCode(condition));
        h = boostHashCombine(h, _hashCode(body));
        return h;
      }

      public Object[] _fieldsToList() {
        return new Object[] { condition, body };
      }

      public Object get(VarContext ctx) {
        while (ping() && (Boolean) condition.get(ctx)) {
          body.get(ctx);
        }
        return null;
      }
    }

    static public class ForEach extends Base implements Evaluable, IFieldsToList {

      static final public String _fieldOrder = "collection var body";

      public Evaluable collection;

      public String var;

      public Evaluable body;

      public ForEach() {
      }

      public ForEach(Evaluable collection, String var, Evaluable body) {
        this.body = body;
        this.var = var;
        this.collection = collection;
      }

      public String toString() {
        return shortClassName_dropNumberPrefix(this) + "(" + collection + ", " + var + ", " + body + ")";
      }

      public boolean equals(Object o) {
        if (!(o instanceof ForEach))
          return false;
        ForEach __6 = (ForEach) o;
        return eq(collection, __6.collection) && eq(var, __6.var) && eq(body, __6.body);
      }

      public int hashCode() {
        int h = 986017354;
        h = boostHashCombine(h, _hashCode(collection));
        h = boostHashCombine(h, _hashCode(var));
        h = boostHashCombine(h, _hashCode(body));
        return h;
      }

      public Object[] _fieldsToList() {
        return new Object[] { collection, var, body };
      }

      public Object get(VarContext ctx) {
        var coll = collection.get(ctx);
        Iterator iterator;
        if (coll instanceof Object[])
          for (var element : ((Object[]) coll)) {
            ping();
            ctx.set(var, element);
            body.get(ctx);
          }
        else if (coll instanceof Iterable) {
          for (var element : ((Iterable) coll)) {
            ping();
            ctx.set(var, element);
            body.get(ctx);
          }
        } else if (coll == null) {
        } else
          throw fail("Not iterable: " + className(coll));
        ctx.unset(var);
        return null;
      }
    }

    static public class IfThen extends Base implements Evaluable, IFieldsToList {

      static final public String _fieldOrder = "condition body";

      public Evaluable condition;

      public Evaluable body;

      public IfThen() {
      }

      public IfThen(Evaluable condition, Evaluable body) {
        this.body = body;
        this.condition = condition;
      }

      public String toString() {
        return shortClassName_dropNumberPrefix(this) + "(" + condition + ", " + body + ")";
      }

      public boolean equals(Object o) {
        if (!(o instanceof IfThen))
          return false;
        IfThen __7 = (IfThen) o;
        return eq(condition, __7.condition) && eq(body, __7.body);
      }

      public int hashCode() {
        int h = -2108234502;
        h = boostHashCombine(h, _hashCode(condition));
        h = boostHashCombine(h, _hashCode(body));
        return h;
      }

      public Object[] _fieldsToList() {
        return new Object[] { condition, body };
      }

      public Object get(VarContext ctx) {
        if ((Boolean) condition.get(ctx))
          return body.get(ctx);
        else
          return null;
      }
    }

    static public class ReturnFromScript extends Base implements Evaluable, IFieldsToList {

      public Script script;

      public Evaluable value;

      public ReturnFromScript() {
      }

      public ReturnFromScript(Script script, Evaluable value) {
        this.value = value;
        this.script = script;
      }

      public boolean equals(Object o) {
        if (!(o instanceof ReturnFromScript))
          return false;
        ReturnFromScript __8 = (ReturnFromScript) o;
        return eq(script, __8.script) && eq(value, __8.value);
      }

      public int hashCode() {
        int h = 1821281925;
        h = boostHashCombine(h, _hashCode(script));
        h = boostHashCombine(h, _hashCode(value));
        return h;
      }

      public Object[] _fieldsToList() {
        return new Object[] { script, value };
      }

      public Object get(VarContext ctx) {
        Object result = value.get(ctx);
        ctx.exitFromScript(script);
        return result;
      }

      public String toString() {
        return formatFunctionCall("ReturnFromScript", script, value);
      }
    }
  }

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

    public void set(A a);

    public A get();

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

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

  static public class Gazelle22_GradientImage {

    public BWImage posterized;

    public double gradientThreshold = .25;

    public BWImage out;

    public PosterizeBWImage op;

    public BWImage unposterized;

    public int w, h, brightnessLevels, singleStep;

    public Gazelle22_GradientImage(BWImage posterized) {
      this.posterized = posterized;
    }

    public boolean init() {
      op = (PosterizeBWImage) getMetaSrc(posterized);
      if (op == null)
        return false;
      unposterized = op.img;
      brightnessLevels = op.brightnessLevels;
      assertSameSize(unposterized, posterized);
      w = posterized.getWidth();
      h = posterized.getHeight();
      singleStep = iceil(doubleRatio(255, brightnessLevels - 1));
      return true;
    }

    public BWImage get() {
      init();
      out = new BWImage(w * 2 + 1, h * 2 + 1);
      for (int y = 0; y < h; y++) for (int x = 0; x < w; x++) {
        if (x < w - 1)
          checkPair(x, y, x + 1, y);
        if (y < h - 1)
          checkPair(x, y, x, y + 1);
      }
      return out;
    }

    public boolean isGradientPoint(int x, int y) {
      if (op == null)
        return false;
      IntMinMax posterizedMinMax = new IntMinMax();
      IntMinMax unposterizedMinMax = new IntMinMax();
      for (int y2 = max(0, y - 1); y2 <= min(h - 1, y + 1); y2++) for (int x2 = max(0, x - 1); x2 <= min(w - 1, x + 1); x2++) {
        posterizedMinMax.add(posterized.getInt(x2, y2));
        unposterizedMinMax.add(unposterized.getInt(x2, y2));
      }
      int posterizedContrast = posterizedMinMax.rangeLength();
      if (posterizedContrast > singleStep)
        return false;
      if (posterizedContrast == 0)
        return true;
      int unposterizedContrast = unposterizedMinMax.rangeLength();
      return unposterizedContrast <= posterizedContrast * gradientThreshold;
    }

    public void checkPair(int x, int y, int x2, int y2) {
      int posterizedContrast = absDiff(posterized.getInt(x, y), posterized.getInt(x2, y2));
      if (posterizedContrast == 0)
        return;
      if (posterizedContrast > singleStep)
        return;
      int realContrast = absDiff(unposterized.getInt(x, y), unposterized.getInt(x2, y2));
      double ratio = doubleRatio(realContrast, singleStep);
      float result = (float) ((.5 - ratio) * 2);
      {
        out.setPixel(x * 2 + 1 - (y2 - y), y * 2 + 1, result);
        out.setPixel(x * 2 + 1, y * 2 + 1 - (x2 - x), result);
      }
    }
  }

  static public class ConceptWithGlobalID extends Concept implements IHasGlobalID {

    public GlobalID globalID = aGlobalIDObjUnlessLoading();

    public GlobalID globalID() {
      return globalID;
    }

    public String globalIDStr() {
      return strOrNull(globalID);
    }

    public String prependGlobalID(String s) {
      return globalID == null ? s : "[" + globalID + "] " + s;
    }
  }

  static public class RollingAverage {

    public int windowSize = 50;

    public int recalcEvery = 1000;

    public int nRecalc;

    public double sum;

    public double[] list;

    public int start, len;

    public RollingAverage() {
    }

    public RollingAverage(int windowSize) {
      this.windowSize = windowSize;
    }

    synchronized public void add(double d) {
      init();
      if (++nRecalc >= recalcEvery) {
        nRecalc = 0;
        sum = 0;
        for (int i = 0; i < len; i++) sum += _get(i);
      }
      if (len == windowSize) {
        sum -= _get(0);
        len--;
        start = (start + 1) % windowSize;
      }
      list[(start + len) % windowSize] = d;
      ++len;
      sum += d;
    }

    public double _get(int i) {
      return list[(start + i) % windowSize];
    }

    synchronized public double get() {
      init();
      return doubleRatio(sum, len);
    }

    public void init() {
      if (list == null)
        list = new double[windowSize];
    }
  }

  static public class Symbol implements CharSequence {

    public String text;

    public Symbol() {
    }

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

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

    public String toString() {
      return text;
    }

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

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

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

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

  static public class ScreenOverlay implements AutoCloseable {

    public JWindow window;

    final public ScreenOverlay setBgColor(Color bgColor) {
      return bgColor(bgColor);
    }

    public ScreenOverlay bgColor(Color bgColor) {
      this.bgColor = bgColor;
      return this;
    }

    final public Color getBgColor() {
      return bgColor();
    }

    public Color bgColor() {
      return bgColor;
    }

    public Color bgColor = colorWithAlpha(Color.blue, 0);

    final public ScreenOverlay setBounds(Rect bounds) {
      return bounds(bounds);
    }

    public ScreenOverlay bounds(Rect bounds) {
      this.bounds = bounds;
      return this;
    }

    final public Rect getBounds() {
      return bounds();
    }

    public Rect bounds() {
      return bounds;
    }

    public Rect bounds;

    final public ScreenOverlay setHideOnMouseOver(boolean hideOnMouseOver) {
      return hideOnMouseOver(hideOnMouseOver);
    }

    public ScreenOverlay hideOnMouseOver(boolean hideOnMouseOver) {
      this.hideOnMouseOver = hideOnMouseOver;
      return this;
    }

    final public boolean getHideOnMouseOver() {
      return hideOnMouseOver();
    }

    public boolean hideOnMouseOver() {
      return hideOnMouseOver;
    }

    public boolean hideOnMouseOver = false;

    final public ScreenOverlay setComponent(Component component) {
      return component(component);
    }

    public ScreenOverlay component(Component component) {
      this.component = component;
      return this;
    }

    final public Component getComponent() {
      return component();
    }

    public Component component() {
      return component;
    }

    public Component component;

    public void show() {
      swing(() -> {
        if (window == null) {
          if (usingJTattoo())
            warn("Screen overlays don't really work with JTattoo");
          assertNotNull("bounds", bounds);
          window = new JWindow();
          window.setBackground(bgColor);
          main.setBounds(window, bounds);
          window.setAlwaysOnTop(true);
          if (component != null)
            window.add(component);
          disposeWindowOnClick(window);
          if (hideOnMouseOver)
            addMouseListener(getContentPane(window), new MouseAdapter() {

              @Override
              public void mouseEntered(MouseEvent e) {
                hide();
              }
            });
        }
        window.setVisible(true);
      });
    }

    final public void close() {
      hide();
    }

    public void hide() {
      swing(() -> {
        if (window == null)
          return;
        window.setVisible(false);
      });
    }

    public void daThing() {
      component(new JPanel() {

        public void paintComponent(Graphics g) {
          g.setColor(Color.RED);
          g.drawRect(0, 0, 511, 511);
        }
      });
    }
  }

  static public class BetterThread extends Thread {

    public Runnable target;

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

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

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

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

    public Runnable getTarget() {
      return target;
    }
  }

  static public class GazelleV_LeftArrowScriptParser extends SimpleLeftToRightParser {

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

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

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

    public G22Utils g22utils() {
      return g22utils;
    }

    public G22Utils g22utils = new G22Utils();

    public List functionContainers;

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

    public BuildingScript currentReturnableScript;

    public int parenLevels;

    static public class MethodOnObject implements IFieldsToList {

      static final public String _fieldOrder = "object method";

      public Object object;

      public String method;

      public MethodOnObject() {
      }

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

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

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

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

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

    public class BuildingScript {

      public boolean returnable = false;

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

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

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

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

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

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

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

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

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

    public GazelleV_LeftArrowScript.Evaluable parseScript(boolean returnable) {
      BuildingScript script = new BuildingScript(returnable);
      var lastReturnableScript = currentReturnableScript;
      if (returnable)
        currentReturnableScript = script;
      try {
        parseScript_2(script);
        var builtScript = script.get();
        currentReturnableScript = lastReturnableScript;
        return builtScript;
      } catch (Throwable e) {
        print("Parsed so far:\n" + script);
        throw rethrowAndAppendToMessage(e, squareBracketed(str(lineAndColumn())));
      }
    }

    public void parseScript_2(BuildingScript script) {
      while (mainLoop()) {
        if (is(";")) {
          next();
          continue;
        }
        if (is("}"))
          break;
        String t = token();
        print("First token of command: " + t);
        if (is("def")) {
          parseFunctionDefinition();
          continue;
        }
        if (is("while")) {
          script.add(parseWhileLoop());
          continue;
        }
        if (is("for")) {
          script.add(parseForEach());
          continue;
        }
        if (is("if")) {
          script.add(parseIfStatement());
          continue;
        }
        if (is("return")) {
          consume();
          var expr = parseExpr();
          {
            script.add(new GazelleV_LeftArrowScript.ReturnFromScript(currentReturnableScript.script, expr));
            continue;
          }
        }
        print("next tokens: " + quote(token(1)) + " " + quote(token(2)));
        if (isIdentifier(t) && eq(token(1), "<") && eq(token(2), "-")) {
          print("Found assignment");
          next(3);
          knownVars.put(t, new LASValueDescriptor());
          script.add(new GazelleV_LeftArrowScript.Assignment(t, parseExpr()));
        } else
          script.add(parseExpr());
      }
    }

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

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

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

    public GazelleV_LeftArrowScript.Evaluable parseExpr() {
      return parseExpr(false);
    }

    public GazelleV_LeftArrowScript.Evaluable parseExpr(boolean inner) {
      if (atEnd())
        return null;
      String t = token();
      printVars("parseExpr", "token", t);
      if (is(";"))
        return null;
      if (is("-") && empty(nextSpace()) && startsWithDigit(token(1)) || startsWithDigit(t)) {
        t = consumeMultiTokenLiteral();
        return isInteger(t) ? _const(parseInt(t)) : _const(parseDouble(t));
      }
      if (isQuoted(t)) {
        consume();
        return _const(unquote(t));
      }
      if (isIdentifier(t)) {
        consume();
        print("Consumed identifier " + t + ", next token: " + token() + ", inner: " + inner);
        return parseExprStartingWithIdentifier(t, inner);
      }
      if (eq(t, "(")) {
        parenLevels++;
        consume();
        print("Consumed opening parens (level " + parenLevels + ")");
        var e = parseExpr();
        print("Consuming closing parens for expr: " + e + " (closing paren level " + parenLevels + ")");
        consume(")");
        parenLevels--;
        return inner ? e : parseCall(e);
      }
      throw fail("Identifier, literal or opening parentheses expected (got: " + quote(t));
    }

    public GazelleV_LeftArrowScript.Evaluable parseExprStartingWithIdentifier(String t, boolean inner) {
      if (eq(t, "true"))
        return _const(true);
      if (eq(t, "false"))
        return _const(false);
      if (eq(t, "null"))
        return _const(null);
      if (eq(t, "new")) {
        String className = assertIdentifier(tpp());
        Object o = findExternalObject(className);
        if (o instanceof Class)
          return new GazelleV_LeftArrowScript.NewObject(((Class) o), parseArguments());
        throw fail("Class not found: " + className);
      }
      var type = knownVars.get(t);
      if (type != null) {
        var e = new GazelleV_LeftArrowScript.GetVar(t).returnType(type);
        print("Found var acccess: " + e + ", " + (!inner ? "Checking for call" : "Returning expression"));
        return inner ? e : parseCall(e);
      }
      if (!inner) {
        var fdef = currentReturnableScript.functionDefs.get(t);
        if (fdef != null)
          return new GazelleV_LeftArrowScript.CallFunction(fdef, parseArguments());
      }
      Object o = findExternalObject(t);
      if (o == null)
        throw fail("Unknown object: " + t);
      else if (inner)
        return _const(o);
      else if (o instanceof Class) {
        if (isIdentifier()) {
          String name = tpp();
          if (hasMethodNamed(((Class) o), name))
            return new GazelleV_LeftArrowScript.CallMethod(_const((Class) o), name, parseArguments());
          var field = getField(((Class) o), name);
          if (field != null) {
            assertCmdEnd();
            return new GazelleV_LeftArrowScript.GetStaticField(field);
          }
          throw fail(name + " not found in " + ((Class) o) + " (looked for method or field)");
        } else
          throw fail("Method name expected: " + token());
      } else if (o instanceof MethodOnObject) {
        if (inner)
          throw fail("Can't call methods in arguments");
        return new GazelleV_LeftArrowScript.CallMethod(_const(((MethodOnObject) o).object), ((MethodOnObject) o).method, parseArguments());
      } else
        return parseCall(_const(o));
    }

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

    public String consumeMultiTokenLiteral() {
      return consumeUntilSpaceOr(() -> atCmdEnd());
    }

    public boolean atCmdEnd() {
      return parenLevels == 0 && atEndOrLineBreak() || is(";") || is("}") || is(")");
    }

    public void assertCmdEnd() {
      if (!atCmdEnd())
        throw fail("Expected end of command");
    }

    public GazelleV_LeftArrowScript.Evaluable parseCall(GazelleV_LeftArrowScript.Evaluable target) {
      if (atCmdEnd() || !isIdentifier())
        return target;
      var start = ptr();
      String methodName = tpp();
      var args = parseArguments();
      if (nempty(args))
        return new GazelleV_LeftArrowScript.CallMethod(target, methodName, args);
      else
        return src(start, new GazelleV_LeftArrowScript.CallMethodOrGetField(target, methodName));
    }

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

    transient public IF1<String, Object> findExternalObject;

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

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

    public Object findExternalObject_base(String name) {
      try {
        String fullName = globalClassNames().get(name);
        if (fullName != null)
          return Class.forName(fullName);
        for (var container : unnullForIteration(functionContainers)) if (hasMethodNamed(container, name))
          return new MethodOnObject(container, name);
        return null;
      } catch (Exception __e) {
        throw rethrow(__e);
      }
    }

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

    public GazelleV_LeftArrowScriptParser allowTheWorld(Object... functionContainers) {
      this.functionContainers = asList(functionContainers);
      globalClassNames_cache = null;
      return this;
    }

    public void printFunctionDefs(GazelleV_LeftArrowScript.Script script) {
      print(values(script.functionDefs));
    }

    public void parseFunctionDefinition() {
      consume("def");
      String functionName = assertIdentifier(tpp());
      List<String> args = new ArrayList();
      while (isIdentifier()) args.add(tpp());
      AutoCloseable __1 = tempMapPutAll(knownVars, mapWithSingleValue(args, new LASValueDescriptor()));
      try {
        var functionBody = parseCurlyBlock(true);
        currentReturnableScript.functionDefs.put(functionName, new GazelleV_LeftArrowScript.FunctionDef(functionName, args, functionBody));
      } finally {
        _close(__1);
      }
    }

    public GazelleV_LeftArrowScript.Evaluable parseCurlyBlock(boolean returnable) {
      consume("{");
      var script = parseScript(returnable);
      consume("}");
      return script;
    }

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

    public GazelleV_LeftArrowScript.Evaluable parseForEach() {
      consume("for");
      String var = assertIdentifier(tpp());
      print("for var", var);
      consume("in");
      var collection = parseExpr();
      print("collection", collection);
      AutoCloseable __2 = tempMapPut(knownVars, var, new LASValueDescriptor());
      try {
        var body = parseCurlyBlock(false);
        return new GazelleV_LeftArrowScript.ForEach(collection, var, body);
      } finally {
        _close(__2);
      }
    }

    public GazelleV_LeftArrowScript.Evaluable parseIfStatement() {
      consume("if");
      var condition = parseExpr();
      var body = parseCurlyBlock(false);
      return new GazelleV_LeftArrowScript.IfThen(condition, body);
    }

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

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

    public Map<String, String> globalClassNames_cache;

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

    public Map<String, String> globalClassNames_load() {
      var packages = mapToTreeSet(importedPackages(), pkg -> pkg + ".");
      var classContainers = classContainerPrefixes();
      Map<String, String> out = new HashMap();
      for (var className : g22utils.classNameResolver().allFullyQualifiedClassNames()) {
        if (isAnonymousClassName(className))
          continue;
        if (!contains(className, '$')) {
          String pkg = longestPrefixInTreeSet(className, packages);
          if (pkg != null) {
            String shortName = dropPrefix(pkg, className);
            if (!shortName.contains("."))
              out.put(shortName, className);
          }
        }
        String container = longestPrefixInTreeSet(className, classContainers);
        if (container != null)
          out.put(dropPrefix(container, className), className);
      }
      return out;
    }

    transient public IF0<Collection<String>> importedPackages;

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

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

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

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

  static public class AWTOnConceptChanges implements AutoCloseable {

    final public AWTOnConceptChanges setComponent(JComponent component) {
      return component(component);
    }

    public AWTOnConceptChanges component(JComponent component) {
      this.component = component;
      return this;
    }

    final public JComponent getComponent() {
      return component();
    }

    public JComponent component() {
      return component;
    }

    public JComponent component;

    final public AWTOnConceptChanges setAction(Runnable action) {
      return action(action);
    }

    public AWTOnConceptChanges action(Runnable action) {
      this.action = action;
      return this;
    }

    final public Runnable getAction() {
      return action();
    }

    public Runnable action() {
      return action;
    }

    public Runnable action;

    final public AWTOnConceptChanges setConcepts(Concepts concepts) {
      return concepts(concepts);
    }

    public AWTOnConceptChanges concepts(Concepts concepts) {
      this.concepts = concepts;
      return this;
    }

    final public Concepts getConcepts() {
      return concepts();
    }

    public Concepts concepts() {
      return concepts;
    }

    public Concepts concepts;

    final public AWTOnConceptChanges setFirstDelay(int firstDelay) {
      return firstDelay(firstDelay);
    }

    public AWTOnConceptChanges firstDelay(int firstDelay) {
      this.firstDelay = firstDelay;
      return this;
    }

    final public int getFirstDelay() {
      return firstDelay();
    }

    public int firstDelay() {
      return firstDelay;
    }

    public int firstDelay;

    final public AWTOnConceptChanges setDelay(int delay) {
      return delay(delay);
    }

    public AWTOnConceptChanges delay(int delay) {
      this.delay = delay;
      return this;
    }

    final public int getDelay() {
      return delay();
    }

    public int delay() {
      return delay;
    }

    public int delay = 500;

    public long changes = -1;

    public javax.swing.Timer timer;

    public AWTOnConceptChanges(Concepts concepts, JComponent component, Runnable action) {
      this.action = action;
      this.component = component;
      this.concepts = concepts;
    }

    public void install() {
      assertNotNull(concepts);
      timer = installTimer(component, delay, firstDelay, new Runnable() {

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

        public String toString() {
          return "_trigger();";
        }
      });
    }

    public void _trigger() {
      long c = concepts.changes;
      if (changes != c) {
        changes = c;
        {
          if (action != null)
            action.run();
        }
      }
    }

    public void close() {
      try {
        {
          cleanUp(timer);
          timer = null;
        }
      } catch (Exception __e) {
        throw rethrow(__e);
      }
    }
  }

  static public class G22LeftArrowScript extends Concept {

    static final public String _fieldOrder = "description code";

    public String description;

    public String code;

    public String myType() {
      return dropPrefix("G22", shortClassName(this));
    }

    public String toString() {
      return or2(description, myType() + " " + id);
    }
  }

  static public class RSyntaxTextAreaWithSearch implements SearchListener, Swingable {

    public JPanel panel;

    final public RSyntaxTextArea getTextArea() {
      return textArea();
    }

    public RSyntaxTextArea textArea() {
      return textArea;
    }

    public RSyntaxTextArea textArea;

    public CollapsibleSectionPanel csp;

    public FindDialog findDialog;

    public ReplaceDialog replaceDialog;

    public FindToolBar findToolBar;

    public ReplaceToolBar replaceToolBar;

    public StatusBar statusBar;

    public RSyntaxTextAreaWithSearch() {
      init();
    }

    public RSyntaxTextAreaWithSearch(String text) {
      init();
      setText(text);
    }

    public JComponent visualize() {
      return panel;
    }

    public void init() {
      swing(() -> {
        rsyntaxTextArea_fixNumPad();
        initSearchDialogs();
        panel = new JPanel(new BorderLayout());
        csp = new CollapsibleSectionPanel();
        panel.add(csp);
        textArea = javaxSyntaxTextArea();
        RTextScrollPane sp = new RTextScrollPane(textArea);
        csp.add(sp);
        ErrorStrip errorStrip = new ErrorStrip(textArea);
        panel.add(errorStrip, BorderLayout.LINE_END);
        statusBar = new StatusBar();
        panel.add(statusBar, BorderLayout.SOUTH);
      });
    }

    public void addItem(Action a, ButtonGroup bg, JMenu menu) {
      JRadioButtonMenuItem item = new JRadioButtonMenuItem(a);
      bg.add(item);
      menu.add(item);
    }

    public JMenuBar createMenuBar() {
      JMenuBar mb = new JMenuBar();
      JMenu menu = new JMenu("Search");
      menu.add(new JMenuItem(new ShowFindDialogAction()));
      menu.add(new JMenuItem(new ShowReplaceDialogAction()));
      menu.add(new JMenuItem(new GoToLineAction()));
      menu.addSeparator();
      int ctrl = getToolkit().getMenuShortcutKeyMask();
      int shift = InputEvent.SHIFT_MASK;
      KeyStroke ks = KeyStroke.getKeyStroke(KeyEvent.VK_F, ctrl | shift);
      Action a = csp.addBottomComponent(ks, findToolBar);
      a.putValue(Action.NAME, "Show Find Search Bar");
      menu.add(new JMenuItem(a));
      ks = KeyStroke.getKeyStroke(KeyEvent.VK_H, ctrl | shift);
      a = csp.addBottomComponent(ks, replaceToolBar);
      a.putValue(Action.NAME, "Show Replace Search Bar");
      menu.add(new JMenuItem(a));
      mb.add(menu);
      return mb;
    }

    public String getSelectedText() {
      return textArea.getSelectedText();
    }

    public void initSearchDialogs() {
      findDialog = new FindDialog((java.awt.Dialog) null, this);
      replaceDialog = new ReplaceDialog((java.awt.Dialog) null, this);
      SearchContext context = findDialog.getSearchContext();
      replaceDialog.setSearchContext(context);
      findToolBar = new FindToolBar(this);
      findToolBar.setSearchContext(context);
      replaceToolBar = new ReplaceToolBar(this);
      replaceToolBar.setSearchContext(context);
    }

    @Override
    public void searchEvent(SearchEvent e) {
      SearchEvent.Type type = e.getType();
      SearchContext context = e.getSearchContext();
      SearchResult result = null;
      switch(type) {
        default:
        case MARK_ALL:
          result = SearchEngine.markAll(textArea, context);
          break;
        case FIND:
          result = SearchEngine.find(textArea, context);
          if (!result.wasFound()) {
            Caret c = textArea.getCaret();
            int pos = c.getDot();
            if (context.getSearchForward()) {
              c.setDot(0);
            } else {
              c.setDot(textArea.getDocument().getLength());
            }
            result = SearchEngine.find(textArea, context);
            if (!result.wasFound()) {
              c.setDot(pos);
              UIManager.getLookAndFeel().provideErrorFeedback(textArea);
            }
          }
          break;
        case REPLACE:
          result = SearchEngine.replace(textArea, context);
          if (!result.wasFound()) {
            UIManager.getLookAndFeel().provideErrorFeedback(textArea);
          }
          break;
        case REPLACE_ALL:
          result = SearchEngine.replaceAll(textArea, context);
          JOptionPane.showMessageDialog(null, result.getCount() + " occurrences replaced.");
          break;
      }
      String text = null;
      if (result.wasFound()) {
        text = "Text found; occurrences marked: " + result.getMarkedCount();
      } else if (type == SearchEvent.Type.MARK_ALL) {
        if (result.getMarkedCount() > 0) {
          text = "Occurrences marked: " + result.getMarkedCount();
        } else {
          text = "";
        }
      } else {
        text = "Text not found";
      }
      statusBar.setText(text);
    }

    public class GoToLineAction extends AbstractAction {

      public GoToLineAction() {
        super("Go To Line...");
        int c = getToolkit().getMenuShortcutKeyMask();
        putValue(ACCELERATOR_KEY, KeyStroke.getKeyStroke(KeyEvent.VK_L, c));
      }

      public void actionPerformed(ActionEvent e) {
        findDialog.setVisible(false);
        replaceDialog.setVisible(false);
        GoToDialog dialog = new GoToDialog((java.awt.Dialog) null);
        dialog.setMaxLineNumberAllowed(textArea.getLineCount());
        dialog.setVisible(true);
        int line = dialog.getLineNumber();
        if (line > 0) {
          try {
            textArea.setCaretPosition(textArea.getLineStartOffset(line - 1));
          } catch (BadLocationException ble) {
            UIManager.getLookAndFeel().provideErrorFeedback(textArea);
            ble.printStackTrace();
          }
        }
      }
    }

    public class ShowFindDialogAction extends AbstractAction {

      public ShowFindDialogAction() {
        super("Find...");
        int c = getToolkit().getMenuShortcutKeyMask();
        putValue(ACCELERATOR_KEY, KeyStroke.getKeyStroke(KeyEvent.VK_F, c));
      }

      public void actionPerformed(ActionEvent e) {
        replaceDialog.setVisible(false);
        findDialog.setVisible(true);
      }
    }

    public class ShowReplaceDialogAction extends AbstractAction {

      public ShowReplaceDialogAction() {
        super("Replace...");
        int c = getToolkit().getMenuShortcutKeyMask();
        putValue(ACCELERATOR_KEY, KeyStroke.getKeyStroke(KeyEvent.VK_H, c));
      }

      public void actionPerformed(ActionEvent e) {
        findDialog.setVisible(false);
        replaceDialog.setVisible(true);
      }
    }

    static public class StatusBar extends JPanel {

      public JLabel label;

      public StatusBar() {
        label = new JLabel(" ");
        setLayout(new BorderLayout());
        add(label, BorderLayout.LINE_START);
        add(new JLabel(new SizeGripIcon()), BorderLayout.LINE_END);
      }

      public void setText(String label) {
        loadableUtils.utils.setText(this.label, label);
      }
    }

    public void setStatus(String text) {
      statusBar.setText(text);
    }

    public void setText(String text) {
      loadableUtils.utils.setText(textArea, text);
    }

    public String getText() {
      return main.getText(textArea);
    }

    public void setEditorFont(final Font font) {
      swing(() -> {
        SyntaxScheme ss = textArea.getSyntaxScheme();
        ss = (SyntaxScheme) ss.clone();
        for (int i = 0; i < ss.getStyleCount(); i++) if (ss.getStyle(i) != null)
          ss.getStyle(i).font = font;
        textArea.setSyntaxScheme(ss);
        textArea.setFont(font);
      });
    }

    public Font getEditorFont() {
      return swing(new F0<Font>() {

        public Font get() {
          try {
            return textArea.getFont();
          } catch (Exception __e) {
            throw rethrow(__e);
          }
        }

        public String toString() {
          return "return textArea.getFont();";
        }
      });
    }

    public int getEditorFontSize() {
      return getEditorFont().getSize();
    }

    public void setEditorFontSize(int size) {
      setEditorFont(deriveFont(getEditorFont(), size));
    }

    public RSyntaxDocument getDocument() {
      return (RSyntaxDocument) textArea.getDocument();
    }

    public Toolkit getToolkit() {
      return panel.getToolkit();
    }
  }

  static public class Lowest<A> {

    public A best;

    public double score;

    transient public Object onChange;

    synchronized public boolean isNewBest(double score) {
      return best == null || score < this.score;
    }

    synchronized public double bestScore() {
      return best == null ? Double.NaN : score;
    }

    public double score() {
      return bestScore();
    }

    synchronized public float floatScore() {
      return best == null ? Float.NaN : (float) score;
    }

    synchronized public float floatScoreOr(float defaultValue) {
      return best == null ? defaultValue : (float) score;
    }

    public boolean put(A a, double score) {
      boolean change = false;
      synchronized (this) {
        if (a != null && isNewBest(score)) {
          best = a;
          this.score = score;
          change = true;
        }
      }
      if (change)
        pcallF(onChange);
      return change;
    }

    synchronized public void clear() {
      best = null;
      score = 0;
    }

    synchronized public A get() {
      return best;
    }

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

    synchronized public Pair<A, Double> pair() {
      return best == null ? null : new Pair(best, bestScore());
    }

    public String toString() {
      return "Score " + formatDouble_significant2(score, 4) + ": " + best;
    }
  }

  static public interface IResourceLoader {

    public String loadSnippet(String snippetID);

    public String getTranspiled(String snippetID);

    public int getSnippetType(String snippetID);

    public String getSnippetTitle(String snippetID);

    public File loadLibrary(String snippetID);

    default public File pathToJavaXJar() {
      return pathToJavaxJar_noResourceLoader();
    }

    default public File getSnippetJar(String snippetID, String transpiledSrc) {
      return null;
    }
  }

  static final public class WeakHasherMap<K, V> extends AbstractMap<K, V> implements Map<K, V> {

    public Hasher hasher = null;

    final public boolean keyEquals(Object k1, Object k2) {
      return (hasher == null ? k1.equals(k2) : hasher.equals(k1, k2));
    }

    final public int keyHashCode(Object k1) {
      return (hasher == null ? k1.hashCode() : hasher.hashCode(k1));
    }

    final public WeakKey WeakKeyCreate(K k) {
      if (k == null)
        return null;
      else
        return new WeakKey(k);
    }

    final public WeakKey WeakKeyCreate(K k, ReferenceQueue<? super K> q) {
      if (k == null)
        return null;
      else
        return new WeakKey(k, q);
    }

    final public class WeakKey extends WeakReference<K> {

      public int hash;

      public WeakKey(K k) {
        super(k);
        hash = keyHashCode(k);
      }

      final public WeakKey create(K k) {
        if (k == null)
          return null;
        else
          return new WeakKey(k);
      }

      public WeakKey(K k, ReferenceQueue<? super K> q) {
        super(k, q);
        hash = keyHashCode(k);
      }

      final public WeakKey create(K k, ReferenceQueue<? super K> q) {
        if (k == null)
          return null;
        else
          return new WeakKey(k, q);
      }

      @Override
      public boolean equals(Object o) {
        if (o == null)
          return false;
        if (this == o)
          return true;
        if (!(o.getClass().equals(WeakKey.class)))
          return false;
        Object t = this.get();
        @SuppressWarnings("unchecked")
        Object u = ((WeakKey) o).get();
        if ((t == null) || (u == null))
          return false;
        if (t == u)
          return true;
        return keyEquals(t, u);
      }

      @Override
      public int hashCode() {
        return hash;
      }
    }

    public HashMap<WeakKey, V> hash;

    public ReferenceQueue<? super K> queue = new ReferenceQueue<K>();

    @SuppressWarnings("unchecked")
    final public void processQueue() {
      WeakKey wk;
      while ((wk = (WeakKey) queue.poll()) != null) {
        hash.remove(wk);
      }
    }

    public WeakHasherMap(int initialCapacity, float loadFactor) {
      hash = new HashMap<WeakKey, V>(initialCapacity, loadFactor);
    }

    public WeakHasherMap(int initialCapacity) {
      hash = new HashMap<WeakKey, V>(initialCapacity);
    }

    public WeakHasherMap() {
      hash = new HashMap<WeakKey, V>();
    }

    public WeakHasherMap(Hasher h) {
      hash = new HashMap<WeakKey, V>();
      hasher = h;
    }

    @Override
    public int size() {
      return entrySet().size();
    }

    @Override
    public boolean isEmpty() {
      return entrySet().isEmpty();
    }

    @Override
    public boolean containsKey(Object key) {
      @SuppressWarnings("unchecked")
      K kkey = (K) key;
      return hash.containsKey(WeakKeyCreate(kkey));
    }

    @Override
    public V get(Object key) {
      @SuppressWarnings("unchecked")
      K kkey = (K) key;
      return hash.get(WeakKeyCreate(kkey));
    }

    @Override
    public V put(K key, V value) {
      processQueue();
      return hash.put(WeakKeyCreate(key, queue), value);
    }

    @Override
    public V remove(Object key) {
      processQueue();
      @SuppressWarnings("unchecked")
      K kkey = (K) key;
      return hash.remove(WeakKeyCreate(kkey));
    }

    @Override
    public void clear() {
      processQueue();
      hash.clear();
    }

    @SuppressWarnings("TypeParameterShadowing")
    final public class Entry<K, V> implements Map.Entry<K, V> {

      public Map.Entry<WeakKey, V> ent;

      public K key;

      public Entry(Map.Entry<WeakKey, V> ent, K key) {
        this.ent = ent;
        this.key = key;
      }

      @Override
      public K getKey() {
        return key;
      }

      @Override
      public V getValue() {
        return ent.getValue();
      }

      @Override
      public V setValue(V value) {
        return ent.setValue(value);
      }

      final public boolean keyvalEquals(K o1, K o2) {
        return (o1 == null) ? (o2 == null) : keyEquals(o1, o2);
      }

      final public boolean valEquals(V o1, V o2) {
        return (o1 == null) ? (o2 == null) : o1.equals(o2);
      }

      @SuppressWarnings("NonOverridingEquals")
      public boolean equals(Map.Entry<K, V> e) {
        return (keyvalEquals(key, e.getKey()) && valEquals(getValue(), e.getValue()));
      }

      @Override
      public int hashCode() {
        V v;
        return (((key == null) ? 0 : keyHashCode(key)) ^ (((v = getValue()) == null) ? 0 : v.hashCode()));
      }
    }

    final public class EntrySet extends AbstractSet<Map.Entry<K, V>> {

      public Set<Map.Entry<WeakKey, V>> hashEntrySet = hash.entrySet();

      @Override
      public Iterator<Map.Entry<K, V>> iterator() {
        return new Iterator<Map.Entry<K, V>>() {

          public Iterator<Map.Entry<WeakKey, V>> hashIterator = hashEntrySet.iterator();

          public Map.Entry<K, V> next = null;

          @Override
          public boolean hasNext() {
            while (hashIterator.hasNext()) {
              Map.Entry<WeakKey, V> ent = hashIterator.next();
              WeakKey wk = ent.getKey();
              K k = null;
              if ((wk != null) && ((k = wk.get()) == null)) {
                continue;
              }
              next = new Entry<K, V>(ent, k);
              return true;
            }
            return false;
          }

          @Override
          public Map.Entry<K, V> next() {
            if ((next == null) && !hasNext())
              throw new NoSuchElementException();
            Map.Entry<K, V> e = next;
            next = null;
            return e;
          }

          @Override
          public void remove() {
            hashIterator.remove();
          }
        };
      }

      @Override
      public boolean isEmpty() {
        return !(iterator().hasNext());
      }

      @Override
      public int size() {
        int j = 0;
        for (Iterator<Map.Entry<K, V>> i = iterator(); i.hasNext(); i.next()) j++;
        return j;
      }

      @Override
      public boolean remove(Object o) {
        processQueue();
        if (!(o instanceof Map.Entry<?, ?>))
          return false;
        @SuppressWarnings("unchecked")
        Map.Entry<K, V> e = (Map.Entry<K, V>) o;
        Object ev = e.getValue();
        WeakKey wk = WeakKeyCreate(e.getKey());
        Object hv = hash.get(wk);
        if ((hv == null) ? ((ev == null) && hash.containsKey(wk)) : hv.equals(ev)) {
          hash.remove(wk);
          return true;
        }
        return false;
      }

      @Override
      public int hashCode() {
        int h = 0;
        for (Iterator<Map.Entry<WeakKey, V>> i = hashEntrySet.iterator(); i.hasNext(); ) {
          Map.Entry<WeakKey, V> ent = i.next();
          WeakKey wk = ent.getKey();
          Object v;
          if (wk == null)
            continue;
          h += (wk.hashCode() ^ (((v = ent.getValue()) == null) ? 0 : v.hashCode()));
        }
        return h;
      }
    }

    public Set<Map.Entry<K, V>> entrySet = null;

    @Override
    public Set<Map.Entry<K, V>> entrySet() {
      if (entrySet == null)
        entrySet = new EntrySet();
      return entrySet;
    }

    public K findKey(Object key) {
      processQueue();
      K kkey = (K) key;
      WeakKey wkey = WeakKeyCreate(kkey);
      WeakKey found = hashMap_findKey(hash, wkey);
      return found == null ? null : found.get();
    }
  }

  static public class TranslucentWindowTest {

    public List<JWindow> windows = new ArrayList();

    public void run() {
      try {
        var screens = GraphicsEnvironment.getLocalGraphicsEnvironment().getScreenDevices();
        System.out.println("Detected " + screens.length + " screen(s)");
        for (int iScreen = 0; iScreen < screens.length; iScreen++) {
          var screen = screens[iScreen].getDefaultConfiguration().getBounds();
          JWindow window = new JWindow();
          window.setBounds(screen.x + screen.width / 4, screen.y + screen.height / 4, screen.width / 2, screen.height / 2);
          window.setBackground(new Color(0, 0, 255, 64));
          window.setAlwaysOnTop(true);
          var label = new JLabel("Screen " + (iScreen + 1) + " of " + screens.length);
          label.setHorizontalAlignment(JLabel.CENTER);
          window.add(label);
          window.setVisible(true);
          windows.add(window);
        }
        doAfter(10.0, new Runnable() {

          public void run() {
            try {
              disposeWindows(windows);
            } catch (Exception __e) {
              throw rethrow(__e);
            }
          }

          public String toString() {
            return "disposeWindows(windows);";
          }
        });
      } catch (Exception __e) {
        throw rethrow(__e);
      }
    }
  }

  static public class RegionBorder_innerPoints extends AbstractSteppable implements IFieldsToList {

    public FastRegions_BWImage regions;

    public int iRegion;

    public RegionBorder_innerPoints() {
    }

    public RegionBorder_innerPoints(FastRegions_BWImage regions, int iRegion) {
      this.iRegion = iRegion;
      this.regions = regions;
    }

    public String toString() {
      return shortClassName_dropNumberPrefix(this) + "(" + regions + ", " + iRegion + ")";
    }

    public Object[] _fieldsToList() {
      return new Object[] { regions, iRegion };
    }

    transient public List<IVF1<Boolean>> onNewTrace;

    public RegionBorder_innerPoints onNewTrace(IVF1<Boolean> f) {
      onNewTrace = syncAddOrCreate(onNewTrace, f);
      return this;
    }

    public RegionBorder_innerPoints removeNewTraceListener(IVF1<Boolean> f) {
      main.remove(onNewTrace, f);
      return this;
    }

    public void newTrace(boolean isHole) {
      pcallFAll(onNewTrace, isHole);
    }

    transient public List<IVF1<Pt>> onFoundPoint;

    public RegionBorder_innerPoints onFoundPoint(IVF1<Pt> f) {
      onFoundPoint = syncAddOrCreate(onFoundPoint, f);
      return this;
    }

    public RegionBorder_innerPoints removeFoundPointListener(IVF1<Pt> f) {
      main.remove(onFoundPoint, f);
      return this;
    }

    public void foundPoint(Pt p) {
      pcallFAll(onFoundPoint, p);
    }

    transient public List<Runnable> onTraceDone;

    public RegionBorder_innerPoints onTraceDone(Runnable r) {
      onTraceDone = syncAddOrCreate(onTraceDone, r);
      return this;
    }

    public RegionBorder_innerPoints removeTraceDoneListener(Runnable r) {
      main.remove(onTraceDone, r);
      return this;
    }

    public void traceDone() {
      pcallFAll(onTraceDone);
    }

    public int w, x, y, dir;

    public FastRegions_BWImage.RegionIterator it;

    public byte[] reachedInDirections;

    public boolean tracing = false;

    final public boolean getTracingHole() {
      return tracingHole();
    }

    public boolean tracingHole() {
      return tracingHole;
    }

    public boolean tracingHole = false;

    static public Pt[] directions = { pt(1, 0), pt(0, 1), pt(-1, 0), pt(0, -1) };

    public void init() {
      w = regions.w;
      reachedInDirections = new byte[w * regions.h];
      it = regions.regionIterator(iRegion);
    }

    public boolean step() {
      if (reachedInDirections == null)
        init();
      if (tracing) {
        int pos = y * w + x;
        if ((reachedInDirections[pos] & (1 << dir)) != 0) {
          traceDone();
          tracing = false;
          return true;
        }
        reachedInDirections[pos] |= (byte) 1 << dir;
        foundPoint(x, y);
        for (int turn = 3; turn <= 6; turn++) {
          int newDir = (dir + turn) & 3;
          Pt d = directions[newDir];
          int x2 = x + d.x, y2 = y + d.y;
          boolean b = regions.inRegion(iRegion, x2, y2);
          if (b) {
            x = x2;
            y = y2;
            dir = newDir;
            return true;
          }
        }
        return true;
      } else {
        if (!it.next())
          return false;
        x = it.x();
        y = it.y();
        if (reachedInDirections[y * w + x] != 0)
          return true;
        if (!regions.inRegion(iRegion, x, y - 1)) {
          startTrace(0);
          return true;
        }
        if (!regions.inRegion(iRegion, x - 1, y)) {
          startTrace(3);
          return true;
        }
        if (!regions.inRegion(iRegion, x + 1, y)) {
          startTrace(1);
          return true;
        }
        if (!regions.inRegion(iRegion, x, y + 1)) {
          startTrace(2);
          return true;
        }
        return true;
      }
    }

    public void startTrace(int dir) {
      this.dir = dir;
      reachedInDirections[y * w + x] = (byte) (15 & ~(1 << dir));
      tracing = true;
      newTrace(tracingHole);
      tracingHole = true;
    }

    public void foundPoint(int x, int y) {
      foundPoint(pt(x, y));
    }

    public List<Pt> allPoints_cache;

    public List<Pt> allPoints() {
      if (allPoints_cache == null)
        allPoints_cache = allPoints_load();
      return allPoints_cache;
    }

    public List<Pt> allPoints_load() {
      PtBuffer l = new PtBuffer();
      onFoundPoint(p -> l.add(p));
      run();
      return l;
    }

    public OnePath onePath_cache;

    public OnePath onePath() {
      if (onePath_cache == null)
        onePath_cache = onePath_load();
      return onePath_cache;
    }

    public OnePath onePath_load() {
      return new OnePath(allPoints(), true);
    }

    public void runAndPrint() {
      onNewTrace(hole -> print(!hole ? "new outline" : "new hole"));
      onTraceDone(() -> print("traceDone"));
      onFoundPoint(p -> print("foundPoint " + p));
      stepMaxWithStats(this, 10000);
    }
  }

  static public class G22ChallengePanel extends HasChangeListeners implements Swingable, IFieldsToList {

    public G22Challenge challenge;

    public G22ChallengePanel() {
    }

    public G22ChallengePanel(G22Challenge challenge) {
      this.challenge = challenge;
    }

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

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

    final public G22ChallengePanel setRandomSeed(long randomSeed) {
      return randomSeed(randomSeed);
    }

    public G22ChallengePanel randomSeed(long randomSeed) {
      if (!eq(this.randomSeed, randomSeed)) {
        this.randomSeed = randomSeed;
        change();
      }
      return this;
    }

    final public long getRandomSeed() {
      return randomSeed();
    }

    public long randomSeed() {
      return randomSeed;
    }

    public long randomSeed = 1;

    transient public DynamicHStack imagesPanel;

    transient public List<Entry> entries = syncL();

    transient public JComponent imagesSection;

    transient public GazelleV_LeftArrowScript.Script parsedScript;

    final public G22ChallengePanel setSolutionTypes(Set<Class> solutionTypes) {
      return solutionTypes(solutionTypes);
    }

    public G22ChallengePanel solutionTypes(Set<Class> solutionTypes) {
      if (!eq(this.solutionTypes, solutionTypes)) {
        this.solutionTypes = solutionTypes;
        change();
      }
      return this;
    }

    final public Set<Class> getSolutionTypes() {
      return solutionTypes();
    }

    public Set<Class> solutionTypes() {
      return solutionTypes;
    }

    public Set<Class> solutionTypes = syncSet();

    transient public JButton btnShowSolutions;

    transient public JLeftArrowScriptIDE recognizerIDE;

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

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

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

    public G22Utils g22utils() {
      return g22utils;
    }

    transient public G22Utils g22utils;

    final public G22ChallengePanel setTimeoutToMakeAnImage(double timeoutToMakeAnImage) {
      return timeoutToMakeAnImage(timeoutToMakeAnImage);
    }

    public G22ChallengePanel timeoutToMakeAnImage(double timeoutToMakeAnImage) {
      this.timeoutToMakeAnImage = timeoutToMakeAnImage;
      return this;
    }

    final public double getTimeoutToMakeAnImage() {
      return timeoutToMakeAnImage();
    }

    public double timeoutToMakeAnImage() {
      return timeoutToMakeAnImage;
    }

    public double timeoutToMakeAnImage = 10.0;

    final public G22ChallengePanel setTimeoutToRecognizeAnImage(double timeoutToRecognizeAnImage) {
      return timeoutToRecognizeAnImage(timeoutToRecognizeAnImage);
    }

    public G22ChallengePanel timeoutToRecognizeAnImage(double timeoutToRecognizeAnImage) {
      this.timeoutToRecognizeAnImage = timeoutToRecognizeAnImage;
      return this;
    }

    final public double getTimeoutToRecognizeAnImage() {
      return timeoutToRecognizeAnImage();
    }

    public double timeoutToRecognizeAnImage() {
      return timeoutToRecognizeAnImage;
    }

    public double timeoutToRecognizeAnImage = 10.0;

    final public G22ChallengePanel setImagesToPaint(int imagesToPaint) {
      return imagesToPaint(imagesToPaint);
    }

    public G22ChallengePanel imagesToPaint(int imagesToPaint) {
      this.imagesToPaint = imagesToPaint;
      return this;
    }

    final public int getImagesToPaint() {
      return imagesToPaint();
    }

    public int imagesToPaint() {
      return imagesToPaint;
    }

    public int imagesToPaint = 3;

    final public G22ChallengePanel setInterval(int interval) {
      return interval(interval);
    }

    public G22ChallengePanel interval(int interval) {
      this.interval = interval;
      return this;
    }

    final public int getInterval() {
      return interval();
    }

    public int interval() {
      return interval;
    }

    public int interval = 100;

    final public G22ChallengePanel setImageDisplaySize(int imageDisplaySize) {
      return imageDisplaySize(imageDisplaySize);
    }

    public G22ChallengePanel imageDisplaySize(int imageDisplaySize) {
      this.imageDisplaySize = imageDisplaySize;
      return this;
    }

    final public int getImageDisplaySize() {
      return imageDisplaySize();
    }

    public int imageDisplaySize() {
      return imageDisplaySize;
    }

    public int imageDisplaySize = 100;

    final public G22ChallengePanel setImageBorderColor1(Color imageBorderColor1) {
      return imageBorderColor1(imageBorderColor1);
    }

    public G22ChallengePanel imageBorderColor1(Color imageBorderColor1) {
      this.imageBorderColor1 = imageBorderColor1;
      return this;
    }

    final public Color getImageBorderColor1() {
      return imageBorderColor1();
    }

    public Color imageBorderColor1() {
      return imageBorderColor1;
    }

    public Color imageBorderColor1 = Color.green;

    final public G22ChallengePanel setImageBorderColor2(Color imageBorderColor2) {
      return imageBorderColor2(imageBorderColor2);
    }

    public G22ChallengePanel imageBorderColor2(Color imageBorderColor2) {
      this.imageBorderColor2 = imageBorderColor2;
      return this;
    }

    final public Color getImageBorderColor2() {
      return imageBorderColor2();
    }

    public Color imageBorderColor2() {
      return imageBorderColor2;
    }

    public Color imageBorderColor2 = Color.red;

    final public G22ChallengePanel setImageBorderSize(int imageBorderSize) {
      return imageBorderSize(imageBorderSize);
    }

    public G22ChallengePanel imageBorderSize(int imageBorderSize) {
      this.imageBorderSize = imageBorderSize;
      return this;
    }

    final public int getImageBorderSize() {
      return imageBorderSize();
    }

    public int imageBorderSize() {
      return imageBorderSize;
    }

    public int imageBorderSize = 1;

    public void init() {
      recognizerIDE = g22utils.leftArrowIDE();
      recognizerIDE.sectionTitle("Recognizer " + roundBracket(recognizerIDE.sectionTitle));
      var old = recognizerIDE.modifyParser;
      recognizerIDE.modifyParser = parser -> {
        recognizerIDE.modifyParser_fallback(old, parser);
        parser.addVar("image");
      };
      recognizerIDE.runScript = () -> {
        var compileResult = recognizerIDE.freshCompileResult();
        var script = compileResult.parsedScript;
        if (script == null)
          return;
        var bg = g22utils.backgroundProcessesUI();
        AutoCloseable __1 = bg == null ? null : bg.tempAdd(new BackgroundProcessesUI.Entry("Run recognizer on " + challenge));
        try {
          VarContext ctx = new VarContext();
          try {
            List<OKOrError> results = syncL();
            long time = sysNow();
            for (Entry entry : filter(entries, e -> e.image != null)) {
              ctx.put("image", entry.image);
              var result = okOrError(() -> recognizerIDE.callCompiledObjectWithTimeout(timeoutToRecognizeAnImage, script, ctx));
              results.add(result);
              entry.computerResult(result);
            }
            time = sysNow() - time;
            recognizerIDE.showScriptResult(OKOrError.ok("Got " + nResults(results) + " in " + formatSeconds(time, 3) + " s"));
          } catch (Throwable e) {
            printStackTrace(e);
            recognizerIDE.showScriptResult(OKOrError.error(e));
          }
        } finally {
          _close(__1);
        }
      };
    }

    public JComponent visualize() {
      if (recognizerIDE == null)
        init();
      imagesPanel = (DynamicHStack) dynamicHStack().spacing(20);
      awtCalcEvery(imagesPanel, interval, new Runnable() {

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

        public String toString() {
          return "_paintAnImage();";
        }
      });
      return withCenteredBoldTitle("Challenge: " + challenge, withTopMargin(jvsplit(northCenterAndSouthWithMargin(centerAndEastWithMargin(centeredLiveValueLabel(liveValue_hasChangeListeners(this, () -> "Looking for: " + solutionTypeDesc())), swing(() -> new JPopDownButton(menu -> menu.add(jMenuItem("Random seed " + n2(randomSeed)))))), imagesSection = jCenteredRaisedSection("Images", jBorderlessHigherScrollPane(jfullcenter(imagesPanel))), withBottomMargin(jCenteredLine(btnShowSolutions = jbutton("Show solutions", () -> showSolutions())))), recognizerIDE.visualize())));
    }

    public void _paintAnImage() {
      if (l(entries) >= imagesToPaint)
        return;
      int index = l(entries) + 1;
      Entry entry = new Entry(index, (int) (randomSeed + index - 1));
      entries.add(entry);
      try {
        if (parsedScript == null) {
          var parser = g22utils.leftArrowParser();
          parsedScript = parser.parse(challenge.code);
        }
        VarContext ctx = new VarContext();
        var returnedObject = evalWithTimeoutOrTypedException(timeoutToMakeAnImage, () -> {
          AutoCloseable __2 = tempSetRandomSeed((int) entry.seed);
          try {
            return parsedScript.get(ctx);
          } finally {
            _close(__2);
          }
        });
        if (returnedObject == null)
          returnedObject = ctx.get("image");
        if (returnedObject == null)
          returnedObject = ctx.get("img");
        if (returnedObject instanceof MakesBufferedImage || returnedObject instanceof Image)
          returnedObject = toBufferedImage(returnedObject);
        if (returnedObject instanceof BufferedImage) {
          entry.solution(ctx.get("solution"));
          updateSolutionType(entry.solution);
          addImage(entry, ((BufferedImage) returnedObject));
        } else if (returnedObject == null)
          addImage(entry, null, jcenteredlabel("No image"));
        else
          addImage(entry, null, jcenteredlabel("Not an image: " + shortClassName(returnedObject)));
      } catch (Throwable e) {
        printStackTrace(e);
        entry.error(e);
        addImage(entry, null, jSmallErrorView(e));
      } finally {
        entry.calculating(false);
      }
    }

    public void addImage(Entry entry, BufferedImage image, JComponent component) {
      entry.image(image).component(component);
      addAndRevalidate(imagesPanel, component);
      setSectionTitle(imagesSection, firstToUpper(nImages(entries)) + " calculated");
    }

    public void addImage(Entry entry, BufferedImage image) {
      entry.image(image);
      addImage(entry, image, new EntryComponent(entry).visualize());
    }

    public class EntryComponent implements Swingable, IFieldsToList {

      public Entry entry;

      public EntryComponent() {
      }

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

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

      public EntryComponent(Entry entry) {
        this.entry = entry;
        entry.entryComponent(this);
      }

      public SingleComponentPanel scpSolution = singleComponentPanel();

      public SingleComponentPanel scpComputerResult = singleComponentPanel();

      public SingleComponentPanel scpCheckmark = singleComponentPanel();

      public JComponent visualize() {
        var image = entry.image;
        double scale = calcFitScale(image, imageDisplaySize);
        var image2 = scaleImageWithOp(image, scale, AffineTransformOp.TYPE_NEAREST_NEIGHBOR);
        for (var color : ll(imageBorderColor1, imageBorderColor2)) image2 = addBorderToImage(image2, color, imageBorderSize);
        String toolTip = "Image " + n2(entry.index) + " of " + challenge + " (seed " + n2(entry.seed) + ", " + image.getWidth() + "*" + image.getHeight() + " px)";
        JButton b = withToolTip(toolTip, jimageButton(image2));
        setMargin(10, b);
        return centerAndSouthWithMargin(b, vstackWithSpacing(scpCheckmark, scpSolution, scpComputerResult));
      }

      public JComponent answerToComponent(Object answer) {
        JComponent c;
        try {
          c = jCenteredLabel(shorten(g22utils.stringify(answer)));
        } catch (Throwable e) {
          c = jSmallErrorView(e);
        }
        return jMaxWidth(imageDisplaySize + 20, c);
      }

      public void showSolution() {
        scpSolution.set(withCenteredTitle("Solution", answerToComponent(entry.solution)));
      }

      public void computerResult(OKOrError result) {
        scpComputerResult.set(withCenteredTitle("Computer Result", result.isOK() ? answerToComponent(result) : jSmallErrorView(result.error())));
        scpCheckmark.set(entry.computerIsCorrect() ? jImage_scaledToHeight(32, checkmarkIconID(), "Computer is correct!!") : null);
      }
    }

    public class Entry {

      public int index;

      public long seed;

      final public Entry setImage(BufferedImage image) {
        return image(image);
      }

      public Entry image(BufferedImage image) {
        this.image = image;
        return this;
      }

      final public BufferedImage getImage() {
        return image();
      }

      public BufferedImage image() {
        return image;
      }

      public BufferedImage image;

      final public Entry setError(Throwable error) {
        return error(error);
      }

      public Entry error(Throwable error) {
        this.error = error;
        return this;
      }

      final public Throwable getError() {
        return error();
      }

      public Throwable error() {
        return error;
      }

      public Throwable error;

      final public Entry setSolution(Object solution) {
        return solution(solution);
      }

      public Entry solution(Object solution) {
        this.solution = solution;
        return this;
      }

      final public Object getSolution() {
        return solution();
      }

      public Object solution() {
        return solution;
      }

      public Object solution;

      public OKOrError computerResult;

      final public Entry setCalculating(boolean calculating) {
        return calculating(calculating);
      }

      public Entry calculating(boolean calculating) {
        this.calculating = calculating;
        return this;
      }

      final public boolean getCalculating() {
        return calculating();
      }

      public boolean calculating() {
        return calculating;
      }

      public boolean calculating = true;

      final public Entry setComponent(JComponent component) {
        return component(component);
      }

      public Entry component(JComponent component) {
        this.component = component;
        return this;
      }

      final public JComponent getComponent() {
        return component();
      }

      public JComponent component() {
        return component;
      }

      public JComponent component;

      final public Entry setEntryComponent(EntryComponent entryComponent) {
        return entryComponent(entryComponent);
      }

      public Entry entryComponent(EntryComponent entryComponent) {
        this.entryComponent = entryComponent;
        return this;
      }

      final public EntryComponent getEntryComponent() {
        return entryComponent();
      }

      public EntryComponent entryComponent() {
        return entryComponent;
      }

      public EntryComponent entryComponent;

      final public Entry setComputerIsCorrect(boolean computerIsCorrect) {
        return computerIsCorrect(computerIsCorrect);
      }

      public Entry computerIsCorrect(boolean computerIsCorrect) {
        this.computerIsCorrect = computerIsCorrect;
        return this;
      }

      final public boolean getComputerIsCorrect() {
        return computerIsCorrect();
      }

      public boolean computerIsCorrect() {
        return computerIsCorrect;
      }

      public boolean computerIsCorrect = false;

      public Entry(int index, long seed) {
        this.seed = seed;
        this.index = index;
      }

      public void computerResult(OKOrError result) {
        this.computerResult = result;
        computerIsCorrect(result.isOK() && eq(solution, result.get()));
        {
          if (entryComponent != null)
            entryComponent.computerResult(result);
        }
      }
    }

    public void updateSolutionType(Object solution) {
      Class c = _getClass(solution);
      if (solutionTypes.add(c))
        change();
    }

    public String solutionTypeDesc() {
      List<String> types = map(__46 -> solutionTypeDesc(__46), solutionTypes);
      return textOut_or(types, "Calculating...");
    }

    public String solutionTypeDesc(Class c) {
      if (c == null)
        return "no solution given";
      if (c == Rect.class)
        return "a rectangular area in the image";
      return aOrAn(shortClassName(c));
    }

    public void showSolutions() {
      disableButton(btnShowSolutions);
      for (var e : cloneList(entries)) if (e.entryComponent != null)
        e.entryComponent.showSolution();
    }
  }

  static public class proxy_InvocationHandler implements InvocationHandler {

    public Object target;

    public proxy_InvocationHandler() {
    }

    public proxy_InvocationHandler(Object target) {
      this.target = target;
    }

    public Object invoke(Object proxy, Method method, Object[] args) {
      return call(target, method.getName(), unnull(args));
    }
  }

  static public class UIURLSystem implements IFieldsToList {

    public Enterable owner;

    public SimpleLiveValue<String> uiURL;

    public UIURLSystem() {
    }

    public UIURLSystem(Enterable owner, SimpleLiveValue<String> uiURL) {
      this.uiURL = uiURL;
      this.owner = owner;
    }

    public String toString() {
      return shortClassName_dropNumberPrefix(this) + "(" + owner + ", " + uiURL + ")";
    }

    public Object[] _fieldsToList() {
      return new Object[] { owner, uiURL };
    }

    transient public Map<String, Entry> uiMap = syncCIMap();

    public List<String> preferredURLs = syncList();

    static public class Entry {

      public String url;

      public String toolTip;

      public IF0<? extends JComponent> makeComponent;

      public Entry(String url, IF0<? extends JComponent> makeComponent) {
        this.makeComponent = makeComponent;
        this.url = url;
      }

      public Entry(String url, String toolTip, IF0<? extends JComponent> makeComponent) {
        this.makeComponent = makeComponent;
        this.toolTip = toolTip;
        this.url = url;
      }
    }

    final public UIURLSystem setScp(SingleComponentPanel scp) {
      return scp(scp);
    }

    public UIURLSystem scp(SingleComponentPanel scp) {
      this.scp = scp;
      return this;
    }

    final public SingleComponentPanel getScp() {
      return scp();
    }

    public SingleComponentPanel scp() {
      return scp;
    }

    transient public SingleComponentPanel scp;

    public JComboBox<String> comboBox;

    public JComponent urlBar() {
      comboBox = jcombobox(urlsForComboBox());
      comboBox.setRenderer(new CenteredComboBoxRenderer(new ListCellRendererWithToolTip<String>(url -> toolTipForURL(url), (ListCellRenderer<String>) comboBox.getRenderer())));
      return withLabel("Show", comboBoxAndButton(onSelectedItem(bindComboBoxToLiveValue(comboBox, uiURL), url -> showUIURL(url)), "Go", url -> showUIURL(url)));
    }

    final public JComponent renderUIURL(String url) {
      return renderUIUrl(url);
    }

    final public JComponent uiGet(String url) {
      return renderUIUrl(url);
    }

    public JComponent renderUIUrl(String url) {
      try {
        AutoCloseable __1 = tempEnter(owner);
        try {
          var entry = uiMap.get(url);
          if (entry == null)
            return jCenteredLabel("URL not found: " + url);
          var component = entry.makeComponent.get();
          return component;
        } finally {
          _close(__1);
        }
      } catch (Throwable e) {
        printStackTrace(e);
        return jErrorView(e);
      }
    }

    public boolean hasURL(String url) {
      return uiMap.containsKey(url);
    }

    public void showUIURL(String url) {
      AutoCloseable __2 = tempEnter(owner);
      try {
        setURL(trim(url));
        go();
      } finally {
        _close(__2);
      }
    }

    public void go() {
      setComponent(scp, renderUIUrl(url()));
    }

    public String url() {
      return uiURL.get();
    }

    public void setURL(String url) {
      uiURL.set(url);
    }

    public UIURLSystem put(WithToolTip<String> url, IF0<? extends JComponent> maker) {
      return put(url.get(), url.toolTip(), maker);
    }

    public UIURLSystem put(String url, IF0<? extends JComponent> maker) {
      return put(url, null, maker);
    }

    public UIURLSystem put(String url, String toolTip, IF0<? extends JComponent> maker) {
      uiMap.put(url, new Entry(url, toolTip, maker));
      return this;
    }

    public String toolTipForURL(String url) {
      var e = uiMap.get(url);
      return e == null ? null : e.toolTip;
    }

    public List<String> urlsForComboBox() {
      var sorted = cloneKeys(uiMap);
      return concatLists(listSetIntersection(preferredURLs, sorted), sorted);
    }

    public void addPreferredUIURL(String uiURL) {
      preferredURLs.add(uiURL);
    }
  }

  static public interface IResourceHolder {

    public <A extends AutoCloseable> A add(A a);

    public Collection<AutoCloseable> takeAll();
  }

  static public class JMiniJavaIDE implements Swingable {

    final public JMiniJavaIDE setLvScript(SimpleLiveValue<String> lvScript) {
      return lvScript(lvScript);
    }

    public JMiniJavaIDE lvScript(SimpleLiveValue<String> lvScript) {
      this.lvScript = lvScript;
      return this;
    }

    final public SimpleLiveValue<String> getLvScript() {
      return lvScript();
    }

    public SimpleLiveValue<String> lvScript() {
      return lvScript;
    }

    public SimpleLiveValue<String> lvScript = stringLiveValue();

    public String sectionTitle = "Mini Java IDE";

    static public String helpText = "Javaaa";

    transient public CompileResult compileResult;

    transient public RSyntaxTextAreaWithSearch taScript;

    transient public Q compileQ = new Q();

    transient public JLabel lblCompileResult;

    transient public JButton btnRun;

    transient public JavaCompletionProvider completionProvider;

    transient public AutoCompletion autoComplete;

    final public JMiniJavaIDE setStringifier(IStringifier stringifier) {
      return stringifier(stringifier);
    }

    public JMiniJavaIDE stringifier(IStringifier stringifier) {
      this.stringifier = stringifier;
      return this;
    }

    final public IStringifier getStringifier() {
      return stringifier();
    }

    public IStringifier stringifier() {
      return stringifier;
    }

    transient public IStringifier stringifier;

    public class JavaCompletionProvider extends DefaultCompletionProvider {

      @Override
      public List<Completion> getCompletionByInputText(String inputText) {
        print("getCompletionByInputText: " + quote(inputText));
        return ll();
      }

      @Override
      public List<Completion> getCompletionsImpl(JTextComponent comp) {
        return getCompletionByInputText(getAlreadyEnteredText(comp));
      }
    }

    public JComponent visualize() {
      taScript = liveValueRSyntaxTextArea_bothWays(lvScript);
      awtCalcEvery(taScript.textArea(), 5.0, () -> compileQ.add(new Runnable() {

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

        public String toString() {
          return "compile();";
        }
      }));
      {
        swing(() -> {
          completionProvider = new JavaCompletionProvider();
          completionProvider.setAutoActivationRules(true, " ");
          autoComplete = new AutoCompletion(completionProvider);
          autoComplete.setAutoActivationEnabled(true);
          autoComplete.install(taScript.textArea);
        });
      }
      return jCenteredSection(sectionTitle, centerAndSouthWithMargin(taScript.visualize(), centerAndEastWithMargin(jBorderlessHigherScrollPane(lblCompileResult = jlabel()), vstack(jline(btnRun = jbutton("Run", runnableThread(new Runnable() {

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

        public String toString() {
          return "runButtonAction();";
        }
      })), jPopDownButton_noText("Show Scripting Help", runnableThread(new Runnable() {

        public void run() {
          try {
            showTextWordWrapped("Gazelle 'Left arrow script' Help", helpText);
          } catch (Exception __e) {
            throw rethrow(__e);
          }
        }

        public String toString() {
          return "showTextWordWrapped(\"Gazelle 'Left arrow script' Help\", helpText)";
        }
      })))))));
    }

    public boolean visible() {
      return isShowing(lblCompileResult);
    }

    public void compile() {
      var script = lvScript.get();
      var result = compileResult;
      if (result == null || !eq(result.script, script)) {
        setStatus("Compiling...");
        try {
          result = new CompileResult();
          result.script = script;
          result.className = "UserCode_" + now();
          result.adaptedScript = adaptScript(result);
          result.java = result.adaptedScript;
          result.compiledObject = veryQuickJava_finish_specialMainClass(result.className, result.java);
          print("compiledObject", result.compiledObject);
        } catch (Throwable e) {
          printStackTrace(e);
          result.compileError = e;
        }
        compileResult = result;
        setText(lblCompileResult, compileResult);
        updateRunButtonState();
      }
    }

    public void updateRunButtonState() {
      setEnabled(btnRun, runButtonShouldBeEnabled());
    }

    transient public IF0<Boolean> runButtonShouldBeEnabled;

    public boolean runButtonShouldBeEnabled() {
      return runButtonShouldBeEnabled != null ? runButtonShouldBeEnabled.get() : runButtonShouldBeEnabled_base();
    }

    final public boolean runButtonShouldBeEnabled_fallback(IF0<Boolean> _f) {
      return _f != null ? _f.get() : runButtonShouldBeEnabled_base();
    }

    public boolean runButtonShouldBeEnabled_base() {
      return compileResult != null && compileResult.runnable();
    }

    public CompileResult freshCompileResult() {
      runInQAndWait(compileQ, new Runnable() {

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

        public String toString() {
          return "compile();";
        }
      });
      return compileResult;
    }

    public Object compiledObject() {
      return freshCompileResult().compiledObject;
    }

    transient public Runnable runButtonAction;

    public void runButtonAction() {
      if (runButtonAction != null)
        runButtonAction.run();
      else
        runButtonAction_base();
    }

    final public void runButtonAction_fallback(Runnable _f) {
      if (_f != null)
        _f.run();
      else
        runButtonAction_base();
    }

    public void runButtonAction_base() {
      runScript();
    }

    public void runScript() {
      var result = freshCompileResult();
      if (result.compiledObject != null) {
        setStatus("Running");
        result.result = okOrError(() -> callCompiledObject(result.compiledObject));
        setStatus(result.result.isOK() ? shorten(stringify(stringifier, result.result.get())) : exceptionToStringShorter(result.result.error()));
      }
    }

    public class CompileResult {

      public String script, adaptedScript, java;

      public String className;

      public Class compiledObject;

      public Throwable compileError;

      public OKOrError result;

      public String toString() {
        if (compileError == null)
          return "Compiled OK";
        String msg = compileError.getMessage();
        msg = dropPrefixFromLines("> ", msg);
        var errors = parseECJOutputForErrors(msg);
        if (nempty(errors)) {
          var error = first(errors);
          print("codeLine", quote(error.codeLine));
          pnlQuoted(asList(lines_iterator(script)));
          int lineNr = indexOfLine(script, tabsToSpaces(error.codeLine));
          error.lineNr = lineNr + 1;
          return str(error);
        }
        return msg;
      }

      public boolean runnable() {
        return compiledObject != null;
      }
    }

    public void setStatus(String status) {
      setText(lblCompileResult, status);
    }

    transient public IF1<String, String> extraClassMembers;

    public String extraClassMembers(String script) {
      return extraClassMembers != null ? extraClassMembers.get(script) : extraClassMembers_base(script);
    }

    final public String extraClassMembers_fallback(IF1<String, String> _f, String script) {
      return _f != null ? _f.get(script) : extraClassMembers_base(script);
    }

    public String extraClassMembers_base(String script) {
      return "";
    }

    transient public IF1<CompileResult, String> adaptScript;

    public String adaptScript(CompileResult result) {
      return adaptScript != null ? adaptScript.get(result) : adaptScript_base(result);
    }

    final public String adaptScript_fallback(IF1<CompileResult, String> _f, CompileResult result) {
      return _f != null ? _f.get(result) : adaptScript_base(result);
    }

    public String adaptScript_base(CompileResult result) {
      return tok_moveImportsUp("class " + result.className + "{" + extraClassMembers(result.script) + "\n" + evalJava_prep(result.script) + "}");
    }

    transient public IF1<Object, Object> callCompiledObject;

    public Object callCompiledObject(Object object) {
      return callCompiledObject != null ? callCompiledObject.get(object) : callCompiledObject_base(object);
    }

    final public Object callCompiledObject_fallback(IF1<Object, Object> _f, Object object) {
      return _f != null ? _f.get(object) : callCompiledObject_base(object);
    }

    public Object callCompiledObject_base(Object object) {
      return callCalc(object);
    }
  }

  static public class ConceptsComboBox<A extends Concept> extends JComboBox<A> {

    public Concepts concepts;

    public Class<A> conceptClass;

    public AWTOnConceptChanges updater;

    public ConceptsComboBox(Concepts concepts, Class<A> conceptClass) {
      this.conceptClass = conceptClass;
      this.concepts = concepts;
      updateItems();
      updater = new AWTOnConceptChanges(concepts, this, () -> updateItems());
      updater.install();
    }

    public void updateItems() {
      setComboBoxItems_notifyListeners(this, sortTheList(asList(freshList())));
    }

    transient public IF0<Collection<A>> freshList;

    public Collection<A> freshList() {
      return freshList != null ? freshList.get() : freshList_base();
    }

    final public Collection<A> freshList_fallback(IF0<Collection<A>> _f) {
      return _f != null ? _f.get() : freshList_base();
    }

    public Collection<A> freshList_base() {
      return main.list(concepts, conceptClass);
    }

    transient public IF1<List<A>, List<A>> sortTheList;

    public List<A> sortTheList(List<A> l) {
      return sortTheList != null ? sortTheList.get(l) : sortTheList_base(l);
    }

    final public List<A> sortTheList_fallback(IF1<List<A>, List<A>> _f, List<A> l) {
      return _f != null ? _f.get(l) : sortTheList_base(l);
    }

    public List<A> sortTheList_base(List<A> l) {
      return sortConceptsByID(l);
    }
  }

  static public class Flattener {

    public List out = new ArrayList();

    public Flattener() {
    }

    public Flattener(Object... l) {
      add(l);
    }

    public void add(Object o) {
      if (o instanceof Object[])
        for (var x : ((Object[]) o)) add(x);
      else if (o instanceof Iterable)
        for (var x : ((Iterable) o)) add(x);
      else if (o != null)
        out.add(o);
    }

    public void add(Object... l) {
      add((Object) l);
    }

    public List toList() {
      return out;
    }

    public Object[] toArray() {
      return toObjectArray(out);
    }
  }

  static public class FlexibleRateTimer implements AutoCloseable {

    public double hertz;

    transient public Runnable action;

    transient public double timestamp;

    transient public DoLater doLater;

    transient public Flag started = new Flag();

    transient volatile public boolean disposed = false;

    transient public long delay;

    transient public List<Runnable> onFrequencyChanged;

    transient public boolean verbose = false;

    static public double minHertz = 0, actualMinHertz = 1e-8, maxHertz = 1000;

    public FlexibleRateTimer() {
    }

    public FlexibleRateTimer(double hertz) {
      this.hertz = hertz;
    }

    public FlexibleRateTimer(double hertz, Runnable action) {
      this.action = action;
      this.hertz = hertz;
    }

    public void start() {
      if (!started.raise())
        return;
      if (verbose)
        print("Starting timer with " + hertz + " Hz");
      vmBus_timerStarted(this);
      _kaboom();
    }

    synchronized public void _kaboom() {
      try {
        if (verbose)
          print(disposed ? "Timer kaboom (disposed)" : "Timer kaboom");
        if (disposed)
          return;
        {
          cleanUp(doLater);
          doLater = null;
        }
        if (hertz <= actualMinHertz) {
          timestamp = 0;
          return;
        }
        if (timestamp == 0)
          timestamp = sysNow();
        timestamp += 1000 / getFrequency();
        long _timestamp = lround(timestamp);
        doLater = new DoLater(_timestamp, new Runnable() {

          public void run() {
            try {
              delay = sysNow() - _timestamp;
              if (verbose)
                print("Timer action");
              pcallF(action);
              _kaboom();
            } catch (Exception __e) {
              throw rethrow(__e);
            }
          }

          public String toString() {
            return "delay = sysNow()-_timestamp;\r\n      if (verbose) print(\"Timer action\");\r\n    ...";
          }
        });
        if (verbose)
          print("Timer scheduled for: " + (_timestamp - sysNow()));
        doLater.enable();
      } catch (Throwable __e) {
        printStackTrace(__e);
      }
    }

    public void cancel() {
      close();
    }

    public synchronized void close() {
      disposed = true;
      {
        cleanUp(doLater);
        doLater = null;
      }
    }

    public void setRunnableAndStart(Runnable action) {
      this.action = action;
      start();
    }

    public void setFrequency(double hertz) {
      synchronized (this) {
        if (disposed)
          return;
        hertz = clamp(hertz, minHertz, maxHertz);
        if (hertz == this.hertz)
          return;
        this.hertz = hertz;
      }
      pcallFAll(onFrequencyChanged);
    }

    public void setFrequencyImmediately(double hertz) {
      synchronized (this) {
        if (disposed)
          return;
        hertz = clamp(hertz, minHertz, maxHertz);
        if (hertz == this.hertz)
          return;
        this.hertz = hertz;
        if (!started.isUp())
          return;
        if (verbose)
          print("Timer setFreq doLater=" + doLater);
        boolean b = doLater == null || doLater.cancel();
        print("Timer cancel result: " + b + " (" + this.hertz + " -> " + hertz + ")");
        timestamp = sysNow();
        if (b)
          _kaboom();
      }
      pcallFAll(onFrequencyChanged);
    }

    synchronized public double getFrequency() {
      return hertz;
    }

    public long currentDelay() {
      return delay;
    }

    synchronized public void onFrequencyChanged(Runnable r) {
      onFrequencyChanged = addOrCreate(onFrequencyChanged, r);
    }

    public void onFrequencyChangedAndNow(Runnable r) {
      onFrequencyChanged(runAndReturn(r));
    }
  }

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

    public int maxSize = 10;

    public MRUCache() {
    }

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

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

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

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

  static public class JGazelleVScriptRunner implements IFieldsToList {

    public SimpleLiveValue<String> lvScript;

    public JGazelleVScriptRunner() {
    }

    public JGazelleVScriptRunner(SimpleLiveValue<String> lvScript) {
      this.lvScript = lvScript;
    }

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

    public GazelleVScript parsedScript;

    public GazelleVScript.Run run;

    public Object result;

    public SingleComponentPanel scpScriptResult = singleComponentPanel();

    public WeakVar<ImageSurface> isScriptResult = new WeakVar();

    public WeakVar<JTextArea> taResult = new WeakVar();

    public JLabel lblScore = jlabel();

    public JComponent scriptAndResultPanel() {
      return northAndCenter(scriptInputField(), scpScriptResult = singleComponentPanel());
    }

    public JComponent scriptInputField() {
      return withMargin(centerAndEastWithMargin(withLabel("Gazelle \"Linear\" Script:", jLiveTextField(lvScript)), jPopDownButton_noText("Show Scripting Help", runnableThread(new Runnable() {

        public void run() {
          try {
            showText("Gazelle 'Linear Script' Help", GazelleVScript.helpText);
          } catch (Exception __e) {
            throw rethrow(__e);
          }
        }

        public String toString() {
          return "showText(\"Gazelle 'Linear Script' Help\", GazelleVScript.helpText)";
        }
      }))));
    }

    public void showScriptOutput() {
      if (result instanceof BWImage) {
        showImageResult((BWImage) result);
      } else if (result instanceof BufferedImage) {
        showImageResult((BufferedImage) result);
      } else if (result instanceof Animation) {
        showImageResult(((Animation) result).toImage());
      } else {
        showTextResult(str(result));
      }
    }

    public void showTextResult(String text) {
      text = shorten(1000, text);
      if (isShowing(taResult.get())) {
        setTextKeepCaret(taResult.get(), text);
      } else {
        var ta = jTextArea_noUndo(text);
        scpScriptResult.set(jscroll(ta));
        taResult.set(ta);
      }
    }

    public void showImageResult(MakesBufferedImage img) {
      showImageResult(toBufferedImage(img));
    }

    public void showImageResult(BufferedImage img) {
      if (img == null)
        return;
      if (isShowing(isScriptResult.get())) {
        isScriptResult.get().setImage(img);
      } else {
        var is = stdImageSurface();
        is.setImage(img);
        scpScriptResult.set(jscroll_centered(is));
        isScriptResult.set(is);
      }
      if (isShowing(lblScore)) {
        String score = "";
        if (sameSize(run.inputImage, img)) {
          double distance = bwDistance(toBWImage(run.inputImage), toBWImage(img));
          score = "Score: " + formatDoubleX(100 * (1 - distance), 1);
        }
        setText(lblScore, score);
      }
    }

    public ImageSurface stdImageSurface() {
      return pixelatedImageSurface().setAutoZoomToDisplay(true).repaintInThread(false);
    }

    public void parse() {
      parsedScript = new GazelleVScript(lvScript.get());
    }

    public void runOn(IBWIntegralImage ii) {
      run = parsedScript.new Run();
      run.setInputImage(ii);
      run.setIntegralImage(ii);
      run.run();
      result = run.result();
    }

    public void parseAndRunOn(IBWIntegralImage ii) {
      try {
        parse();
        runOn(ii);
      } catch (Throwable e) {
        result = exceptionToStringShort(e);
        printStackTrace(e);
      }
      showScriptOutput();
    }
  }

  static public class AlphanumComparator implements Comparator<String> {

    public boolean ignoreCase = false;

    final public boolean isDigit(char ch) {
      return ((ch >= 48) && (ch <= 57));
    }

    final public String getChunk(String s, int slength, int marker) {
      StringBuilder chunk = new StringBuilder();
      char c = s.charAt(marker);
      chunk.append(c);
      marker++;
      if (isDigit(c))
        while (marker < slength) {
          c = s.charAt(marker);
          if (!isDigit(c))
            break;
          chunk.append(c);
          marker++;
        }
      else
        while (marker < slength) {
          c = s.charAt(marker);
          if (isDigit(c))
            break;
          chunk.append(c);
          marker++;
        }
      return chunk.toString();
    }

    public int compare(String s1, String s2) {
      if (s1 == null)
        return s2 == null ? 0 : -1;
      if (s2 == null)
        return 1;
      int thisMarker = 0;
      int thatMarker = 0;
      int s1Length = s1.length();
      int s2Length = s2.length();
      while (thisMarker < s1Length && thatMarker < s2Length) {
        String thisChunk = getChunk(s1, s1Length, thisMarker);
        thisMarker += thisChunk.length();
        String thatChunk = getChunk(s2, s2Length, thatMarker);
        thatMarker += thatChunk.length();
        int result = 0;
        if (isDigit(thisChunk.charAt(0)) && isDigit(thatChunk.charAt(0))) {
          int thisChunkLength = thisChunk.length();
          result = thisChunkLength - thatChunk.length();
          if (result == 0) {
            for (int i = 0; i < thisChunkLength; i++) {
              result = thisChunk.charAt(i) - thatChunk.charAt(i);
              if (result != 0) {
                return result;
              }
            }
          }
        } else {
          result = thisChunk.compareTo(thatChunk);
        }
        if (result != 0)
          return result;
      }
      return s1Length - s2Length;
    }
  }

  static public class DoubleFPSCounter {

    public FPSCounter counter = new FPSCounter();

    volatile public double value;

    public void inc() {
      if (counter.secondsSinceStart() >= 1) {
        value = counter.get();
        counter = new FPSCounter();
      }
      counter.inc();
    }

    public double get() {
      return value;
    }
  }

  static public class FileWatchService implements AutoCloseable {

    final public FileWatchService setInterval(int interval) {
      return interval(interval);
    }

    public FileWatchService interval(int interval) {
      this.interval = interval;
      return this;
    }

    final public int getInterval() {
      return interval();
    }

    public int interval() {
      return interval;
    }

    public int interval = 50;

    public int sleepSeconds = 60;

    public WatchService watchService;

    public MultiMap<WatchKey, IVF1<File>> listeners = new MultiMap();

    public Thread pollThread;

    volatile public boolean closed = false;

    public FileWatchService() {
      try {
        watchService = FileSystems.getDefault().newWatchService();
      } catch (Exception __e) {
        throw rethrow(__e);
      }
    }

    public void close() {
      closed = true;
      {
        cleanUp(watchService);
        watchService = null;
      }
    }

    public WatchKey addListenerImpl(File path, IVF1<File> listener, WatchEvent.Kind... eventKinds) {
      try {
        if (path == null)
          return null;
        startPollThread();
        WatchKey key = path.toPath().register(watchService, eventKinds);
        listeners.put(key, listener);
        return key;
      } catch (Exception __e) {
        throw rethrow(__e);
      }
    }

    public void addNonRecursiveListener(File path, IVF1<File> listener) {
      addListenerImpl(path, listener, jdk_watchService_allEventKinds());
    }

    public void addRecursiveListener(File path, IVF1<File> listener) {
      Set<File> listeningTo = synchroSet();
      IVF1<File> listener2 = new IVF1<File>() {

        public void get(File f) {
          boolean isDir = f.isDirectory();
          if (isDir && listeningTo.add(f))
            try {
              addListenerImpl(f, this, jdk_watchService_allEventKinds());
            } catch (Throwable __e) {
              print(exceptionToStringShort(__e));
            }
          callF(listener, f);
        }
      };
      addListenerImpl(path, listener2, jdk_watchService_allEventKinds());
      for (File subDir : findAllDirs(path)) addListenerImpl(subDir, listener2, jdk_watchService_allEventKinds());
    }

    synchronized public void startPollThread() {
      if (pollThread != null)
        return;
      pollThread = startThread("File Watch Service", new Runnable() {

        public void run() {
          try {
            try {
              while (licensed() && !closed) {
                WatchKey key = watchService.poll(sleepSeconds, TimeUnit.SECONDS);
                if (key != null) {
                  Path dir = (Path) (key.watchable());
                  sleep(interval);
                  List<WatchEvent<?>> events = key.pollEvents();
                  LinkedHashSet<File> changedFiles = new LinkedHashSet();
                  for (WatchEvent<?> event : reversedIterator(events)) {
                    try {
                      final Path changed = (Path) event.context();
                      if (changed == null)
                        continue;
                      File full = newFile(dir.toFile(), changed.toFile().getPath());
                      changedFiles.add(full);
                    } catch (Throwable __e) {
                      printStackTrace(__e);
                    }
                  }
                  for (File f : changedFiles) pcallFAll(listeners.get(key), f);
                  key.reset();
                }
              }
            } catch (ClosedWatchServiceException e) {
            }
          } catch (Exception __e) {
            throw rethrow(__e);
          }
        }

        public String toString() {
          return "try {\r\n        while (licensed() && !closed) { \r\n          WatchKey key = wat...";
        }
      });
    }
  }

  static public class LASValueDescriptor {

    public boolean knownValue() {
      return false;
    }

    public Object value() {
      return null;
    }

    public Class javaClass() {
      return null;
    }

    public boolean javaClassIsExact() {
      return false;
    }

    public boolean canBeNull() {
      return true;
    }

    public boolean canFail() {
      return false;
    }

    public boolean willFail() {
      return false;
    }

    static public class Exact extends LASValueDescriptor implements IFieldsToList {

      public Class c;

      public boolean canBeNull = false;

      public Exact() {
      }

      public Exact(Class c, boolean canBeNull) {
        this.canBeNull = canBeNull;
        this.c = c;
      }

      public String toString() {
        return shortClassName_dropNumberPrefix(this) + "(" + c + ", " + canBeNull + ")";
      }

      public boolean equals(Object o) {
        if (!(o instanceof Exact))
          return false;
        Exact __1 = (Exact) o;
        return eq(c, __1.c) && eq(canBeNull, __1.canBeNull);
      }

      public int hashCode() {
        int h = 67394271;
        h = boostHashCombine(h, _hashCode(c));
        h = boostHashCombine(h, _hashCode(canBeNull));
        return h;
      }

      public Object[] _fieldsToList() {
        return new Object[] { c, canBeNull };
      }

      public Class javaClass() {
        return c;
      }

      public boolean javaClassIsExact() {
        return true;
      }

      public boolean canBeNull() {
        return canBeNull;
      }
    }

    static public class NonExact extends LASValueDescriptor implements IFieldsToList {

      public Class c;

      public boolean canBeNull = false;

      public NonExact() {
      }

      public NonExact(Class c, boolean canBeNull) {
        this.canBeNull = canBeNull;
        this.c = c;
      }

      public String toString() {
        return shortClassName_dropNumberPrefix(this) + "(" + c + ", " + canBeNull + ")";
      }

      public boolean equals(Object o) {
        if (!(o instanceof NonExact))
          return false;
        NonExact __2 = (NonExact) o;
        return eq(c, __2.c) && eq(canBeNull, __2.canBeNull);
      }

      public int hashCode() {
        int h = 1445514322;
        h = boostHashCombine(h, _hashCode(c));
        h = boostHashCombine(h, _hashCode(canBeNull));
        return h;
      }

      public Object[] _fieldsToList() {
        return new Object[] { c, canBeNull };
      }

      public Class javaClass() {
        return c;
      }

      public boolean javaClassIsExact() {
        return false;
      }

      public boolean canBeNull() {
        return canBeNull;
      }
    }

    static public class KnownValue extends LASValueDescriptor implements IFieldsToList {

      public Object value;

      public KnownValue() {
      }

      public KnownValue(Object value) {
        this.value = value;
      }

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

      public boolean equals(Object o) {
        if (!(o instanceof KnownValue))
          return false;
        KnownValue __3 = (KnownValue) o;
        return eq(value, __3.value);
      }

      public int hashCode() {
        int h = -1456305138;
        h = boostHashCombine(h, _hashCode(value));
        return h;
      }

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

      public boolean knownValue() {
        return true;
      }

      public Object value() {
        return value;
      }

      public Class javaClass() {
        return value == null ? null : value.getClass();
      }

      public boolean javaClassIsExact() {
        return value != null;
      }

      public boolean canBeNull() {
        return value == null;
      }
    }

    static public class WillFail extends LASValueDescriptor {

      public boolean canFail() {
        return true;
      }

      public boolean willFail() {
        return true;
      }
    }

    static public LASValueDescriptor fromClass(Class c) {
      return new NonExact(c, true);
    }
  }

  static public class TokenRangeWithSrc extends TokenRange {

    public List<String> tok;

    public TokenRangeWithSrc() {
    }

    public TokenRangeWithSrc(List<String> tok, int start) {
      this.start = start;
      end = start;
    }

    public TokenRangeWithSrc(List<String> tok, int start, int end) {
      this.end = end;
      this.start = start;
    }

    public TokenRangeWithSrc(ListAndIndex<String> startPtr, ListAndIndex<String> endPtr) {
      assertSame(tok = startPtr.list(), endPtr.list());
      start = startPtr.idx();
      end = endPtr.idx();
    }

    public ListAndIndex<String> startPtr() {
      return new ListAndIndex(tok, start);
    }

    public ListAndIndex<String> endPtr() {
      return new ListAndIndex(tok, end);
    }

    public LineAndColumn startLineAndCol() {
      return tokenToLineAndColumn(startPtr());
    }

    public LineAndColumn endLineAndCol() {
      return tokenToLineAndColumn(endPtr());
    }

    public String toString() {
      var start = startLineAndCol();
      if (eq(start, end))
        return str(start);
      return start + " to " + endLineAndCol();
    }
  }

  static public class MultiSetMap<A, B> {

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

    public int size;

    public MultiSetMap() {
    }

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

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

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

    public boolean put(A key, B value) {
      synchronized (data) {
        Set<B> set = data.get(key);
        if (set == null)
          data.put(key, set = _makeEmptySet());
        if (!set.add(value))
          return false;
        {
          ++size;
          return true;
        }
      }
    }

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

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

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

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

    final public boolean contains(A key, B value) {
      return containsPair(key, value);
    }

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

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

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

    public Set<B> get(A key) {
      synchronized (data) {
        Set<B> set = data.get(key);
        return set == null ? Collections.<B>emptySet() : set;
      }
    }

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

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

    public Set<B> getActual(A key) {
      synchronized (data) {
        Set<B> set = data.get(key);
        if (set == null)
          data.put(key, set = _makeEmptySet());
        return set;
      }
    }

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

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

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

    public void remove(A key) {
      synchronized (data) {
        size -= l(data.get(key));
        data.remove(key);
      }
    }

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

    public void clear() {
      synchronized (data) {
        data.clear();
        size = 0;
      }
    }

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

    public B getFirst(A key) {
      synchronized (data) {
        return first(get(key));
      }
    }

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

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

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

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

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

    public int getSize(A key) {
      return l(data.get(key));
    }

    public int count(A key) {
      return getSize(key);
    }

    public Set<A> reverseGet(B b) {
      synchronized (data) {
        Set<A> l = new HashSet();
        for (A key : data.keySet()) if (data.get(key).contains(b))
          l.add(key);
        return l;
      }
    }

    public A keyForValue(B b) {
      synchronized (data) {
        for (A key : data.keySet()) if (data.get(key).contains(b))
          return key;
        return null;
      }
    }

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

    public boolean isEmpty() {
      synchronized (data) {
        return data.isEmpty();
      }
    }

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

    public Collection<Set<B>> allLists() {
      synchronized (data) {
        return new HashSet(data.values());
      }
    }

    public List<B> allValues() {
      return concatLists(values(data));
    }

    public List<Pair<A, B>> allEntries() {
      synchronized (data) {
        List<Pair<A, B>> l = emptyList(size);
        for (Map.Entry<? extends A, ? extends Set<B>> __0 : _entrySet(data)) {
          A a = __0.getKey();
          Set<B> set = __0.getValue();
          for (B b : set) l.add(pair(a, b));
        }
        return l;
      }
    }

    public Object mutex() {
      return data;
    }

    public String toString() {
      return "mm" + str(data);
    }

    public Pair<A, B> firstEntry() {
      synchronized (data) {
        if (empty(data))
          return null;
        Map.Entry<A, Set<B>> entry = data.entrySet().iterator().next();
        return pair(entry.getKey(), first(entry.getValue()));
      }
    }

    public A firstKey() {
      synchronized (data) {
        return main.firstKey(data);
      }
    }

    public A lastKey() {
      synchronized (data) {
        return (A) ((NavigableMap) data).lastKey();
      }
    }

    public A higherKey(Object a) {
      synchronized (data) {
        return (A) ((NavigableMap) data).higherKey(a);
      }
    }
  }

  static public class ButtonImageLoader {

    public DynamicStack stack;

    public Set<JButton> loadedButtons = weakIdentityHashSet();

    public DeQ loadQ;

    public JScrollPane scrollPane;

    public ChangeListener changeListener;

    public int imageHeight = 128;

    public ButtonImageLoader(final DynamicStack stack) {
      this.stack = stack;
      bindToComponent(stack, new Runnable() {

        public void run() {
          try {
            scrollPane = enclosingScrollPane(stack);
            changeListener = scrollPaneOnScroll(scrollPane, new Runnable() {

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

              public String toString() {
                return "update()";
              }
            });
            update();
          } catch (Exception __e) {
            throw rethrow(__e);
          }
        }

        public String toString() {
          return "scrollPane = enclosingScrollPane(stack);\r\n      changeListener = scrollPaneOn...";
        }
      }, new Runnable() {

        public void run() {
          try {
            if (scrollPane != null) {
              scrollPane.getViewport().removeChangeListener(changeListener);
              scrollPane = null;
              changeListener = null;
            }
          } catch (Exception __e) {
            throw rethrow(__e);
          }
        }

        public String toString() {
          return "if (scrollPane != null) {\r\n        scrollPane.getViewport().removeChangeListe...";
        }
      });
    }

    public void update() {
      swing(() -> {
        for (final JButton b : reversed((List<JButton>) (List) stackElementsShowing(stack))) {
          if (add_byContains(loadedButtons, b)) {
            try {
              TextImageAction tia = makeNiceButtons_map.get(b);
              if (tia == null) {
                print("no tia");
                continue;
              }
              final File f = filesForNiceButtons_map.get(tia);
              if (f == null) {
                print("no file");
                continue;
              }
              qAdd(new Runnable() {

                public void run() {
                  try {
                    setAButtonsImage(b, f);
                  } catch (Exception __e) {
                    throw rethrow(__e);
                  }
                }

                public String toString() {
                  return "setAButtonsImage(b, f)";
                }
              });
            } catch (Throwable __e) {
              printStackTrace(__e);
            }
          }
        }
      });
    }

    public void qAdd(Runnable r) {
      if (loadQ == null)
        loadQ = startDeQ();
      loadQ.addFirst(r);
    }

    public void setAButtonsImage(JButton b, File f) {
      setButtonImage(b, loadPreviewImage(f));
    }

    public BufferedImage loadPreviewImage(File f) {
      return loadPreviewImageWithExactHeight(imageHeight, f);
    }
  }

  static public class ClassNameResolver {

    final public ClassNameResolver setByteCodePath(File byteCodePath) {
      return byteCodePath(byteCodePath);
    }

    public ClassNameResolver byteCodePath(File byteCodePath) {
      this.byteCodePath = byteCodePath;
      return this;
    }

    final public File getByteCodePath() {
      return byteCodePath();
    }

    public File byteCodePath() {
      return byteCodePath;
    }

    public File byteCodePath = byteCodePathForClass(getClass());

    public List<String> importedPackages = itemPlusList("java.lang", endingWith_dropSuffix(standardImports(), ".*"));

    public Set<String> allFullyQualifiedClassNames_cache;

    public Set<String> allFullyQualifiedClassNames() {
      if (allFullyQualifiedClassNames_cache == null)
        allFullyQualifiedClassNames_cache = allFullyQualifiedClassNames_load();
      return allFullyQualifiedClassNames_cache;
    }

    public Set<String> allFullyQualifiedClassNames_load() {
      Set<String> set = new HashSet();
      assertNotNull(byteCodePath);
      set.addAll(classNamesInJarOrDir(byteCodePath));
      printVars("ClassNameResolver", "byteCodePath", byteCodePath, "classesFound", l(set));
      set.addAll(classNamesInLoadedJigsawModules());
      return set;
    }

    public ClassNameResolver init() {
      allFullyQualifiedClassNames();
      return this;
    }

    public String findClass(String name) {
      for (String pkg : importedPackages) {
        String fullName = pkg + "." + name;
        if (allFullyQualifiedClassNames().contains(fullName))
          return fullName;
      }
      return null;
    }

    public void printMe() {
      printVars("ClassNameResolver", "byteCodePath", byteCodePath);
      print("importedPackages", importedPackages);
    }
  }

  static public class JPopDownButton extends JButton {

    public String menuPosition = "left";

    public JPopDownButton() {
      super(unicode_downPointingTriangle());
      loadableUtils.utils.addActionListener(this, new Runnable() {

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

        public String toString() {
          return "openMenu();";
        }
      });
    }

    public JPopDownButton(IVF1<JPopupMenu> fillMenu) {
      this();
      this.fillMenu = fillMenu;
    }

    transient public IVF1<JPopupMenu> fillMenu;

    public void fillMenu(JPopupMenu menu) {
      if (fillMenu != null)
        fillMenu.get(menu);
      else
        fillMenu_base(menu);
    }

    final public void fillMenu_fallback(IVF1<JPopupMenu> _f, JPopupMenu menu) {
      if (_f != null)
        _f.get(menu);
      else
        fillMenu_base(menu);
    }

    public void fillMenu_base(JPopupMenu menu) {
    }

    public void openMenu() {
      JPopupMenu menu = new JPopupMenu();
      int emptyCount = menu.getComponentCount();
      fillMenu(menu);
      if (menu.getComponentCount() == emptyCount)
        return;
      int x = 0;
      if (eq(menuPosition, "center"))
        x = (getWidth() - getPreferredWidth(menu)) / 2;
      else if (eq(menuPosition, "right"))
        x = getWidth() - getPreferredWidth(menu);
      menu.show(this, x, getHeight());
    }
  }

  static public class CombinedStringifier<A> implements IStringifier<A> {

    public CopyOnWriteArrayList<IPartialStringifier<A>> stringifiers = new CopyOnWriteArrayList();

    public IStringifier<A> defaultStringifier = new Stringifier_ToString();

    public CombinedStringifier(IPartialStringifier<A>... stringifiers) {
      addAll(this.stringifiers, stringifiers);
    }

    public String toString(A o) {
      for (var stringifier : stringifiers) {
        String s = stringifier.toStringOpt(o);
        if (s != null)
          return s;
      }
      return defaultStringifier.toString(o);
    }

    public String toString() {
      return formatFunctionCall("CombinedStringifier", listPlus((List) stringifiers, defaultStringifier));
    }
  }

  public interface IStringifier<A> {

    public String toString(A o);
  }

  static public class WeakVar<A> implements IVar<A> {

    public WeakReference<A> ref;

    public synchronized void set(A a) {
      ref = weakRef(a);
    }

    public synchronized A get() {
      if (ref == null)
        return null;
      A value = ref.get();
      if (value == null)
        ref = null;
      return value;
    }
  }

  static public class DoLater implements AutoCloseable {

    public long targetSysTime;

    volatile public Runnable action;

    transient public ISleeper sleeper;

    transient public Executor executor;

    transient public Flag enabled = new Flag();

    transient public Flag cancelledOrExecuted = new Flag();

    public DoLater() {
    }

    public DoLater(long targetSysTime, Runnable action) {
      this.action = action;
      this.targetSysTime = targetSysTime;
    }

    public void enable() {
      if (!enabled.raise())
        return;
      if (sleeper == null)
        sleeper = defaultSleeper();
      sleeper.doLater(targetSysTime, new Runnable() {

        public void run() {
          try {
            if (!cancelledOrExecuted.raise())
              return;
            runWithExecutor(action, executor);
          } catch (Exception __e) {
            throw rethrow(__e);
          }
        }

        public String toString() {
          return "if (!cancelledOrExecuted.raise()) return;\r\n      runWithExecutor(action, exec...";
        }
      });
    }

    public boolean cancel() {
      if (!cancelledOrExecuted.raise())
        return false;
      {
        close();
        return true;
      }
    }

    public void close() {
      cancelledOrExecuted.raise();
      {
        cleanUp(sleeper);
        sleeper = null;
      }
    }
  }

  static public class AnimatedLine extends Animation {

    public int maxSpeed = 1;

    public int y, speed;

    public void start() {
      y = random(h);
      newSpeed();
    }

    public void newSpeed() {
      speed = random_incl(-maxSpeed, maxSpeed);
    }

    public void paint() {
      fillRect(g, 0, 0, w, h, Color.white);
      drawLine(g, 0, y, w, y, Color.black);
    }

    public void nextFrame() {
      if (oneIn(20))
        newSpeed();
      y = clamp(y + speed, 0, h - 1);
    }
  }

  abstract static public class ConceptFieldIndexBase<A extends Concept, Val> implements IConceptIndex, IFieldIndex<A, Val>, IConceptCounter, AutoCloseable {

    public Concepts concepts;

    public Class<A> cc;

    public String field;

    public Map<A, Val> objectToValue = syncHashMap();

    public MultiSetMap<Val, A> valueToObject;

    public ConceptFieldIndexBase() {
      init();
    }

    public ConceptFieldIndexBase(Class<A> cc, String field) {
      this(db_mainConcepts(), cc, field);
    }

    public ConceptFieldIndexBase(Concepts concepts, Class<A> cc, String field) {
      this();
      this.field = field;
      this.cc = cc;
      this.concepts = concepts;
      concepts.addConceptIndex(this);
      updateAll();
      register();
      updateAll();
    }

    public void updateAll() {
      for (A c : setToIndex()) updateImpl(c);
    }

    public Collection<A> setToIndex() {
      return list(concepts, cc);
    }

    abstract public void init();

    abstract public void register();

    public void update(Concept c) {
      if (!isInstance(cc, c))
        return;
      updateImpl((A) c);
    }

    synchronized public void updateImpl(A c) {
      Val newValue = (Val) (cget(c, field));
      Val oldValue = objectToValue.get(c);
      if (newValue == oldValue && (oldValue != null || objectToValue.containsKey(c)))
        return;
      valueToObject.remove(oldValue, c);
      valueToObject.put(newValue, c);
      put(objectToValue, c, newValue);
    }

    public synchronized void remove(Concept c) {
      if (!isInstance(cc, c))
        return;
      if (!objectToValue.containsKey(c))
        return;
      Val value = objectToValue.get(c);
      objectToValue.remove(c);
      valueToObject.remove(value, (A) c);
    }

    synchronized public A get(Val value) {
      return valueToObject.getFirst(value);
    }

    public synchronized Collection<A> getAll(Val value) {
      return valueToObject.get(value);
    }

    public synchronized List<Val> allValues() {
      return cloneKeys_noSync(valueToObject.data);
    }

    public IterableIterator<A> objectIterator() {
      return navigableMultiSetMapValuesIterator_concurrent(valueToObject, this);
    }

    public synchronized MultiSet<Val> allValues_multiSet() {
      return multiSetMapToMultiSet(valueToObject);
    }

    public Class<? extends Concept> conceptClass() {
      return cc;
    }

    public int countConcepts() {
      return l(objectToValue);
    }

    public Collection<Concept> allConcepts() {
      return (Collection) keys(objectToValue);
    }

    public Object mutex() {
      return this;
    }

    public void close() {
      try {
        concepts.removeConceptIndex(this);
      } catch (Exception __e) {
        throw rethrow(__e);
      }
    }
  }

  public interface IHasChangeListeners {

    public IHasChangeListeners onChange(Runnable r);

    public IHasChangeListeners removeChangeListener(Runnable r);

    default public void onChangeAndNow(Runnable l) {
      onChange(l);
      callF(l);
    }
  }

  static public class IntMinMax {

    public int min = Integer.MAX_VALUE, max = Integer.MIN_VALUE;

    public void add(int i) {
      if (i < min)
        min = i;
      if (i > max)
        max = i;
    }

    public int rangeLength() {
      return max - min;
    }
  }

  static public class ImageSurface_PositionToolTip extends ImageSurfaceMouseHandler {

    public ImageSurface_PositionToolTip(ImageSurface is) {
      if (containsInstance(is.tools, ImageSurface_PositionToolTip.class))
        return;
      register(is);
    }

    final public void mouseDragged(MouseEvent e) {
      mouseMoved(e);
    }

    public void mouseMoved(MouseEvent e) {
      setToolTip(is, getPt(e));
    }
  }

  static public class JObjectTable<A> implements Swingable {

    public List<A> data = new ArrayList();

    transient public IF1<A, Map> itemToMap;

    transient public Set<String> hideFields;

    transient public boolean debug, fieldsInOrder = true, withSearcher;

    final public JObjectTable<A> setDefaultAction(IVF1<A> defaultAction) {
      return defaultAction(defaultAction);
    }

    public JObjectTable<A> defaultAction(IVF1<A> defaultAction) {
      this.defaultAction = defaultAction;
      return this;
    }

    final public IVF1<A> getDefaultAction() {
      return defaultAction();
    }

    public IVF1<A> defaultAction() {
      return defaultAction;
    }

    public IVF1<A> defaultAction;

    final public JTable getTable() {
      return table();
    }

    public JTable table() {
      return table;
    }

    transient public JTable table;

    transient public TableSearcher searcher;

    transient public boolean useStruct = false;

    transient public List<Runnable> onListChanged;

    public JObjectTable<A> onListChanged(Runnable r) {
      onListChanged = syncAddOrCreate(onListChanged, r);
      return this;
    }

    public JObjectTable<A> removeListChangedListener(Runnable r) {
      main.remove(onListChanged, r);
      return this;
    }

    public void listChanged() {
      pcallFAll(onListChanged);
    }

    public JObjectTable() {
      itemToMap = a -> {
        if (a instanceof String)
          return litorderedmap("", (String) a);
        Map map = humanizeKeys(fieldsInOrder ? objectToMap_inOrder_withoutFields(a, hideFields) : objectToMap(a));
        if (!useStruct)
          map = mapValues(__68 -> strOrEmpty(__68), map);
        return map;
      };
    }

    public void onListChangedAndNow(Runnable r) {
      if (r == null)
        return;
      onListChanged(r);
      r.run();
    }

    public JComponent visualize() {
      List<Map> l = map(itemToMap, data);
      table = dataToTable_uneditable(sexyTable(), l);
      onDoubleClickOrEnter(table, new VF1<Integer>() {

        public void get(Integer row) {
          try {
            A a = _get(data, row);
            if (a != null) {
              if (defaultAction != null)
                defaultAction.get(a);
            }
          } catch (Exception __e) {
            throw rethrow(__e);
          }
        }

        public String toString() {
          return "A a = _get(data, row);\r\n      if (a != null) defaultAction?.get(a);";
        }
      });
      if (withSearcher)
        return (searcher = tableWithSearcher2(table)).panel;
      return jscroll(table);
    }

    public void updateTable() {
      if (table != null) {
        swing(() -> {
          Point scrollPosition = enclosingViewPosition(table);
          if (debug)
            print("Scroll position: " + scrollPosition);
          dataToTable_uneditable(table, map(itemToMap, data));
          setEnclosingViewPosition(table, scrollPosition);
          if (searcher != null)
            searcher.rowIndices = null;
          if (debug)
            print("dataToTable done, alerting " + n2(onListChanged, "listener"));
        });
      }
      listChanged();
    }

    public void clear() {
      syncClear(data);
      fireDataChanged();
    }

    public void add(A a) {
      syncAdd(data, a);
      fireDataChanged();
    }

    public A addAndReturn(A a) {
      add(a);
      return a;
    }

    public void add(int idx, A a) {
      syncAdd(data, idx, a);
      fireDataChanged();
    }

    public void addAll(Collection<A> l) {
      if (empty(l))
        return;
      syncAddAll(data, l);
      fireDataChanged();
    }

    public void addAndScrollDown(A a) {
      add(a);
      scrollDown();
    }

    public void remove(A a) {
      syncRemove(data, a);
      fireDataChanged();
    }

    public void removeAll(List<A> a) {
      syncRemoveAll(data, a);
      fireDataChanged();
    }

    public void setList(Iterable<A> data) {
      setData(data);
    }

    public void removeSelected() {
      removeAll(allSelected());
    }

    public void setData(Iterable<A> data) {
      setData(data, false);
    }

    public void setData(Iterable<A> data, boolean force) {
      {
        swing(() -> {
          int[] selection = selectedTableRows_array(table);
          List<A> cloned = cloneList(data);
          if (force || !eq(this.data, cloned)) {
            this.data = cloned;
            updateTable();
          }
          selectTableRows(table, selection);
        });
      }
    }

    public int count() {
      return syncL(data);
    }

    public void setData_force(Iterable<A> data) {
      setData(data, true);
    }

    public void fireDataChanged() {
      setData_force(data);
    }

    public int rowFromSearcher(int i) {
      return searcher == null || searcher.rowIndices == null ? i : or(get(searcher.rowIndices, i), -1);
    }

    public A selected() {
      return syncGet(data, rowFromSearcher(selectedTableRowInModel(table)));
    }

    public List<A> allSelected() {
      return syncListGetMulti(data, selectedIndices());
    }

    public int selectedIndex() {
      return selectedTableRow(table);
    }

    public List<Integer> selectedIndices() {
      return map(i -> rowFromSearcher(i), selectedTableRowsInModel(table));
    }

    public boolean selectItem(A a) {
      int i = indexOf(data, a);
      selectRow(table, i);
      return i >= 0;
    }

    public void doubleClickItem(A a) {
      if (selectItem(a)) {
        if (defaultAction != null)
          defaultAction.get(a);
      }
    }

    public void popupMenuItem(String text, IVF1<A> r) {
      tablePopupMenuItemsThreaded(table, text, _convertRunnable(r));
    }

    public void popupMenuItem_top(String text, IVF1<A> r) {
      tablePopupMenuItemsThreaded_top(table, text, _convertRunnable(r));
    }

    public IVF1<Integer> _convertRunnable(IVF1<A> r) {
      return r == null ? null : idx -> r.get(syncGet(data, idx));
    }

    public void hideFields(String... fields) {
      if (hideFields == null)
        hideFields = new HashSet();
      _addAll(hideFields, fields);
    }

    public A getRow(int row) {
      return get(data, row);
    }

    public void scrollDown() {
      scrollTableDownNow(table);
    }
  }

  static public class SimpleLeftToRightParser {

    public String text;

    public List<String> tok;

    final public ListAndIndex<String> getPtr() {
      return ptr();
    }

    public ListAndIndex<String> ptr() {
      return ptr;
    }

    public ListAndIndex<String> ptr;

    public ListAndIndex<String> mainLoopPtr;

    public String currentToken;

    public boolean caseInsensitive = false;

    public List warnings = new ArrayList();

    public SimpleLeftToRightParser() {
    }

    public SimpleLeftToRightParser(String text) {
      this.text = text;
    }

    public SimpleLeftToRightParser(List<String> tok) {
      this.tok = tok;
    }

    final public String token() {
      return t();
    }

    public String t() {
      return currentToken;
    }

    public String token(int i) {
      return get(tok, ptr.idx() + i * 2);
    }

    public String tpp() {
      var t = t();
      next();
      return t;
    }

    public String lastSpace() {
      return get(tok, ptr.idx() - 1);
    }

    public String nextSpace() {
      return get(tok, ptr.idx() + 1);
    }

    public boolean is(String t) {
      return eqOrEqic(caseInsensitive, currentToken, t);
    }

    public boolean was(String t) {
      return eqOrEqic(caseInsensitive, token(-1), t);
    }

    public boolean isInteger() {
      return isInteger(t());
    }

    public boolean isInteger(String s) {
      return main.isInteger(s);
    }

    public boolean isIdentifier() {
      return isIdentifier(t());
    }

    public boolean isIdentifier(String s) {
      return loadableUtils.utils.isIdentifier(s);
    }

    final public void consume() {
      next();
    }

    public void next() {
      if (!endOfText())
        ptr(ptr.plus(2));
    }

    public void consume(String token) {
      if (!is(token))
        throw fail("Expected " + quote(token) + ", got " + quote(token()));
      consume();
    }

    public void ptr(ListAndIndex<String> ptr) {
      this.ptr = ptr;
      fetch();
    }

    public int idx() {
      return ptr.idx();
    }

    public int lTok() {
      return l(tok);
    }

    final public boolean endOfText() {
      return atEnd();
    }

    public boolean atEnd() {
      return ptr.atEnd();
    }

    public void fetch() {
      currentToken = ptr.get();
    }

    public boolean lineBreak() {
      return containsLineBreak(get(tok, ptr.idx() - 1));
    }

    public boolean atEndOrLineBreak() {
      return atEnd() || lineBreak();
    }

    public void init() {
      if (tok == null)
        tok = javaTok(text);
      if (ptr == null)
        ptr(new ListAndIndex(tok, 1));
    }

    public boolean mainLoop() {
      init();
      if (atEnd())
        return false;
      if (eq(mainLoopPtr, ptr))
        throw fail("main loop didn't advance (current token: " + quote(token()) + ")");
      mainLoopPtr = ptr;
      return true;
    }

    public void unknownToken() {
      warn("Unknown token: " + t());
    }

    public void warn(String msg) {
      warnings.add(print(msg));
    }

    public void next(int n) {
      ptr(ptr.idx() + n * 2);
    }

    public void ptr(int i) {
      ptr(new ListAndIndex(tok, min(i | 1, l(tok))));
    }

    public LineAndColumn lineAndColumn() {
      return tokenToLineAndColumn(ptr);
    }

    public String consumeUntilSpaceOr(IF0<Boolean> pred) {
      int i = idx();
      do next(); while (!atEnd() && empty(lastSpace()) && !pred.get());
      return joinSubList(tok, i, idx() - 1);
    }

    public void setText(String text) {
      this.text = text;
      tok = null;
      ptr = null;
    }
  }

  static public class PosterizeBWImage implements IFieldsToList {

    public int brightnessLevels;

    public BWImage img;

    public PosterizeBWImage() {
    }

    public PosterizeBWImage(int brightnessLevels, BWImage img) {
      this.img = img;
      this.brightnessLevels = brightnessLevels;
    }

    public String toString() {
      return shortClassName_dropNumberPrefix(this) + "(" + brightnessLevels + ", " + img + ")";
    }

    public Object[] _fieldsToList() {
      return new Object[] { brightnessLevels, img };
    }

    public BWImage result;

    public void run() {
      try {
        if (brightnessLevels >= 256 || img == null) {
          result = img;
          return;
        }
        byte[] pixels = img.getBytes();
        int w = img.getWidth(), h = img.getHeight(), n = pixels.length;
        byte[] pixels2 = new byte[n];
        double factor1 = doubleRatio(brightnessLevels, 256);
        double factor2 = doubleRatio(255, brightnessLevels - 1);
        for (int i = 0; i < n; i++) pixels2[i] = (byte) iround(ifloor(ubyteToInt(pixels[i]) * factor1) * factor2);
        result = new BWImage(w, h, pixels2);
      } catch (Exception __e) {
        throw rethrow(__e);
      }
    }
  }

  static public class ListCellRendererWithToolTip<A> implements ListCellRenderer<A>, IFieldsToList {

    public IF1<A, String> makeToolTip;

    public ListCellRenderer<A> baseRenderer;

    public ListCellRendererWithToolTip() {
    }

    public ListCellRendererWithToolTip(IF1<A, String> makeToolTip, ListCellRenderer<A> baseRenderer) {
      this.baseRenderer = baseRenderer;
      this.makeToolTip = makeToolTip;
    }

    public String toString() {
      return shortClassName_dropNumberPrefix(this) + "(" + makeToolTip + ", " + baseRenderer + ")";
    }

    public Object[] _fieldsToList() {
      return new Object[] { makeToolTip, baseRenderer };
    }

    public Component getListCellRendererComponent(JList list, A value, int index, boolean isSelected, boolean cellHasFocus) {
      var c = baseRenderer.getListCellRendererComponent(list, value, index, isSelected, cellHasFocus);
      if (c instanceof JComponent) {
        try {
          ((JComponent) c).setToolTipText(makeToolTip == null ? null : makeToolTip.get((A) value));
        } catch (Throwable __e) {
          printStackTrace(__e);
        }
      }
      return ((JComponent) c);
    }
  }

  static public class LeftArrowScriptAutoCompleter extends Meta implements IFieldsToList {

    public GazelleV_LeftArrowScriptParser parser;

    public LeftArrowScriptAutoCompleter() {
    }

    public LeftArrowScriptAutoCompleter(GazelleV_LeftArrowScriptParser parser) {
      this.parser = parser;
    }

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

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

    public List<String> tok;

    public CharInToken cursor;

    public String typedCharacters;

    public ScoredStringSearcher searcher;

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

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

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

    public G22Utils g22utils() {
      return g22utils;
    }

    public G22Utils g22utils;

    public LeftArrowScriptAutoCompleter(G22Utils g22utils, GazelleV_LeftArrowScriptParser parser) {
      this.parser = parser;
      this.g22utils = g22utils;
    }

    public void seek(String text, int iChar) {
      parser.setText(text);
      parser.init();
      tok = parser.tok;
      cursor = charIndexToCharInToken(tok, iChar);
      if (even(cursor.iTok) && cursor.iTok > 0 && cursor.iChar == 0) {
        cursor.iTok--;
        cursor.iChar = l(token());
      }
      if (cursor.iTok > 1 && cursor.iChar == 0 && empty(space())) {
        cursor.iTok -= 2;
        cursor.iChar = l(token());
      }
      typedCharacters = takeFirst(cursor.token(), cursor.iChar);
    }

    public String typedCharacters() {
      return typedCharacters;
    }

    public String space() {
      return get(tok, cursor.iTok - 1);
    }

    public String token() {
      return get(tok, cursor.iTok);
    }

    public String prevToken() {
      return get(tok, cursor.iTok - 2);
    }

    public boolean beginningOfCmd() {
      return eqOneOf(prevToken(), ";", "{", "}") || containsNewLine(space());
    }

    public Collection<String> getCompletions() {
      return searcher().get_transformListWithinScore(__1 -> stringsSortedByLength(__1));
    }

    public ScoredStringSearcher searcher() {
      searcher = new ScoredStringSearcher(typedCharacters);
      if (empty(typedCharacters))
        searcher.returnAll = true;
      String prev = prevToken();
      if (scaffoldingEnabled(this))
        printVars("LeftArrowScriptAutoCompleter", "beginningOfCmd", beginningOfCmd(), "prev", prev, "cursor", cursor, "typedCharacters", typedCharacters, "globalClassNames", l(parser.globalClassNames()));
      if (beginningOfCmd() || !isIdentifier(prev) || eq(prev, "new")) {
        addToSearcher(globalMethodNames());
        addToSearcher(keys(parser.globalClassNames()));
      }
      addToSearcher("true", "false", "null");
      return searcher;
    }

    transient public IF0<Collection<String>> globalMethodNames;

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

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

    public Collection<String> globalMethodNames_base() {
      return concatMap(__69 -> methodNames(__69), parser.functionContainers);
    }

    public void addToSearcher(String... l) {
      addToSearcher(asList(l));
    }

    public void addToSearcher(Iterable<String> l) {
      for (var s : unnullForIteration(l)) if (!eq(s, typedCharacters))
        searcher.add(s);
    }
  }

  static public interface ISetter<A> {

    public void set(A a);
  }

  static public class VarContext {

    public VarContext parent;

    public Map<String, Object> vars;

    public VarContext() {
    }

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

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

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

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

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

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

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

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

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

    public Object exitFromScript() {
      return exitFromScript;
    }

    public Object exitFromScript;
  }

  static public class TimestampRange implements IFieldsToList {

    static final public String _fieldOrder = "start end";

    public Timestamp start;

    public Timestamp end;

    public TimestampRange() {
    }

    public TimestampRange(Timestamp start, Timestamp end) {
      this.end = end;
      this.start = start;
    }

    public String toString() {
      return shortClassName_dropNumberPrefix(this) + "(" + start + ", " + end + ")";
    }

    public boolean equals(Object o) {
      if (!(o instanceof TimestampRange))
        return false;
      TimestampRange __1 = (TimestampRange) o;
      return eq(start, __1.start) && eq(end, __1.end);
    }

    public int hashCode() {
      int h = -2020922905;
      h = boostHashCombine(h, _hashCode(start));
      h = boostHashCombine(h, _hashCode(end));
      return h;
    }

    public Object[] _fieldsToList() {
      return new Object[] { start, end };
    }

    public TimestampRange(long start, long end) {
      this(new Timestamp(start), new Timestamp(end));
    }

    public TimestampRange start(Timestamp start) {
      this.start = start;
      return this;
    }

    public TimestampRange end(Timestamp end) {
      this.end = end;
      return this;
    }
  }

  static public class FailedRule extends RuleWithParams {

    public List<Exp> satisfiedConditions;

    public Exp remainingCondition;

    public FailedRule() {
    }

    public FailedRule(IfThen rule, VarMatches matches, Exp remainingCondition) {
      this.remainingCondition = remainingCondition;
      this.matches = matches;
      this.rule = rule;
    }

    public FailedRule(IfThen rule, VarMatches matches, List<Exp> satisfiedConditions, Exp remainingCondition) {
      this.remainingCondition = remainingCondition;
      this.satisfiedConditions = satisfiedConditions;
      this.matches = matches;
      this.rule = rule;
    }
  }

  static public class RuleWithParams implements IFieldsToList {

    static final public String _fieldOrder = "rule matches";

    public IfThen rule;

    public VarMatches matches;

    public RuleWithParams() {
    }

    public RuleWithParams(IfThen rule, VarMatches matches) {
      this.matches = matches;
      this.rule = rule;
    }

    public String toString() {
      return shortClassName_dropNumberPrefix(this) + "(" + rule + ", " + matches + ")";
    }

    public boolean equals(Object o) {
      if (!(o instanceof RuleWithParams))
        return false;
      RuleWithParams __7 = (RuleWithParams) o;
      return eq(rule, __7.rule) && eq(matches, __7.matches);
    }

    public int hashCode() {
      int h = 1254104616;
      h = boostHashCombine(h, _hashCode(rule));
      h = boostHashCombine(h, _hashCode(matches));
      return h;
    }

    public Object[] _fieldsToList() {
      return new Object[] { rule, matches };
    }

    public String ruleID() {
      return rule.globalID;
    }
  }

  static public class IfThen implements IFieldsToList {

    static final public String _fieldOrder = "in out globalID options originalText";

    public Exp in;

    public Exp out;

    public IfThen() {
    }

    public IfThen(Exp in, Exp out) {
      this.out = out;
      this.in = in;
    }

    public boolean equals(Object o) {
      if (!(o instanceof IfThen))
        return false;
      IfThen __8 = (IfThen) o;
      return eq(in, __8.in) && eq(out, __8.out);
    }

    public int hashCode() {
      int h = -2108234502;
      h = boostHashCombine(h, _hashCode(in));
      h = boostHashCombine(h, _hashCode(out));
      return h;
    }

    public Object[] _fieldsToList() {
      return new Object[] { in, out };
    }

    public String globalID;

    public Set<String> options;

    public String originalText;

    public String text() {
      Collection<String> opt = options;
      if (nempty(globalID))
        opt = concatLists(ll("id: " + globalID), opt);
      return (nempty(opt) ? "[" + joinWithComma(opt) + "] " : "") + (in == null ? "" : in.text() + "\n  => ") + nlLogic_text(out);
    }

    public String toString() {
      return text();
    }
  }

  abstract static public class Exp {

    abstract public String text();

    public String toString() {
      return text();
    }
  }

  static public class Func extends Exp implements IFieldsToList {

    public String name;

    public Exp arg;

    public Func() {
    }

    public Func(String name, Exp arg) {
      this.arg = arg;
      this.name = name;
    }

    public boolean equals(Object o) {
      if (!(o instanceof Func))
        return false;
      Func __0 = (Func) o;
      return eq(name, __0.name) && eq(arg, __0.arg);
    }

    public int hashCode() {
      int h = 2201316;
      h = boostHashCombine(h, _hashCode(name));
      h = boostHashCombine(h, _hashCode(arg));
      return h;
    }

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

    public List<String> options;

    public Func(String name, List<String> options, Exp arg) {
      this.arg = arg;
      this.options = options;
      this.name = name;
    }

    public String text() {
      return name + (empty(options) ? "" : "[" + joinWithComma(options) + "]") + "(" + arg.text() + ")";
    }

    public String argText() {
      return nlLogic_text(arg);
    }
  }

  static public class And extends Exp implements IFieldsToList {

    public Exp a;

    public Exp b;

    public And() {
    }

    public And(Exp a, Exp b) {
      this.b = b;
      this.a = a;
    }

    public boolean equals(Object o) {
      if (!(o instanceof And))
        return false;
      And __1 = (And) o;
      return eq(a, __1.a) && eq(b, __1.b);
    }

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

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

    public String text() {
      return a.text() + "\n  && " + b.text();
    }
  }

  static public class ExpNot extends Exp implements IFieldsToList {

    public Exp a;

    public ExpNot() {
    }

    public ExpNot(Exp a) {
      this.a = a;
    }

    public boolean equals(Object o) {
      if (!(o instanceof ExpNot))
        return false;
      ExpNot __2 = (ExpNot) o;
      return eq(a, __2.a);
    }

    public int hashCode() {
      int h = 2089649046;
      h = boostHashCombine(h, _hashCode(a));
      return h;
    }

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

    public String text() {
      return "!" + a.text();
    }
  }

  abstract static public class Literal extends Exp {
  }

  static public class Sentence extends Literal implements IFieldsToList {

    public List<String> tok;

    public Sentence() {
    }

    public Sentence(List<String> tok) {
      this.tok = tok;
    }

    public boolean equals(Object o) {
      if (!(o instanceof Sentence))
        return false;
      Sentence __3 = (Sentence) o;
      return eq(tok, __3.tok);
    }

    public int hashCode() {
      int h = 1327381123;
      h = boostHashCombine(h, _hashCode(tok));
      return h;
    }

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

    public String text() {
      return join(tok);
    }
  }

  static public class Sentence2 extends Literal implements IFieldsToList {

    public String text;

    public Sentence2() {
    }

    public Sentence2(String text) {
      this.text = text;
    }

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

    public int hashCode() {
      int h = -1800858097;
      h = boostHashCombine(h, _hashCode(text));
      return h;
    }

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

    public String text() {
      return text;
    }
  }

  static public class Eq extends Exp implements IFieldsToList {

    public Exp left;

    public Exp right;

    public Eq() {
    }

    public Eq(Exp left, Exp right) {
      this.right = right;
      this.left = left;
    }

    public boolean equals(Object o) {
      if (!(o instanceof Eq))
        return false;
      Eq __5 = (Eq) o;
      return eq(left, __5.left) && eq(right, __5.right);
    }

    public int hashCode() {
      int h = 2252;
      h = boostHashCombine(h, _hashCode(left));
      h = boostHashCombine(h, _hashCode(right));
      return h;
    }

    public Object[] _fieldsToList() {
      return new Object[] { left, right };
    }

    public String text() {
      return left.text() + " = " + right.text();
    }
  }

  static public class HasChangeListeners implements IHasChangeListeners {

    transient public List<Runnable> onChange;

    public HasChangeListeners onChange(Runnable r) {
      onChange = syncAddOrCreate(onChange, r);
      return this;
    }

    public HasChangeListeners removeChangeListener(Runnable r) {
      main.remove(onChange, r);
      return this;
    }

    public void change() {
      pcallFAll(onChange);
    }
  }

  static public class Flag implements Runnable {

    public boolean up = false;

    public synchronized boolean raise() {
      if (!up) {
        up = true;
        notifyAll();
        return true;
      } else
        return false;
    }

    public synchronized void waitUntilUp() {
      while (!up) {
        try {
          wait();
        } catch (InterruptedException e) {
          e.printStackTrace();
        }
      }
    }

    public boolean waitUntilUp(double timeout) {
      return waitUntilUp(toMS(timeout));
    }

    public synchronized boolean waitUntilUp(long timeout) {
      if (!up) {
        try {
          wait(timeout);
        } catch (InterruptedException e) {
          e.printStackTrace();
        }
      }
      return isUp();
    }

    public synchronized boolean isUp() {
      return up;
    }

    public boolean get() {
      return isUp();
    }

    public String toString() {
      return isUp() ? "up" : "down";
    }

    public void waitForThisOr(Flag otherFlag) {
      try {
        while (!isUp() && !otherFlag.isUp()) Thread.sleep(50);
      } catch (Exception __e) {
        throw rethrow(__e);
      }
    }

    public void run() {
      raise();
    }
  }

  abstract static public class AbstractSteppable implements Steppable {

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

  static public interface IHasGlobalID {

    public GlobalID globalID();
  }

  static public class TextImageAction {

    public String text;

    public String imageID;

    public Object action;

    public String toolTip;

    public VF1<JPopupMenu> popupMenuMaker;

    public Map more;

    public TextImageAction() {
    }

    public TextImageAction(String text, String imageID, Object action) {
      this.action = action;
      this.imageID = imageID;
      this.text = text;
    }
  }

  static public List<String> _stickyLibs_1400546 = ll("#1400546", "#1400547", "#1400548");

  static public class PtBuffer extends RandomAccessAbstractList<Pt> {

    public LongBuffer buf = new LongBuffer();

    public PtBuffer() {
    }

    public PtBuffer(int size) {
      buf.allocate(size);
    }

    public PtBuffer(Iterable<Pt> l) {
      if (l != null)
        for (Pt p : l) add(p);
    }

    public int size() {
      return buf.size();
    }

    public Pt get(int i) {
      return longToPt(buf.get(i));
    }

    public Pt set(int i, Pt val) {
      Pt old = get(i);
      buf.set(i, ptToLong(val));
      return old;
    }

    public boolean add(Pt p) {
      buf.add(ptToLong(p));
      return true;
    }

    public void add(int x, int y) {
      buf.add(ptToLong(x, y));
    }
  }

  static public class DynamicHStack extends DynamicStack {

    public DynamicHStack() {
    }

    public DynamicHStack(boolean useFiller) {
      super(useFiller);
    }

    public GridBagConstraints _componentConstraints() {
      return gridBagConstraints_hstack_1(spacing);
    }

    public GridBagConstraints _fillerConstraints() {
      return gridBagConstraints_hstack_rest();
    }
  }

  static public class CenteredComboBoxRenderer<A> implements ListCellRenderer<A>, IFieldsToList {

    public ListCellRenderer<A> baseRenderer;

    public CenteredComboBoxRenderer() {
    }

    public CenteredComboBoxRenderer(ListCellRenderer<A> baseRenderer) {
      this.baseRenderer = baseRenderer;
    }

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

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

    public Component getListCellRendererComponent(JList list, A value, int index, boolean isSelected, boolean cellHasFocus) {
      var c = baseRenderer.getListCellRendererComponent(list, value, index, isSelected, cellHasFocus);
      if (c instanceof JLabel) {
        if (index < 0)
          centerLabel((JLabel) c);
        else
          leftAlignLabel((JLabel) c);
      }
      return c;
    }
  }

  abstract static public class Animation {

    public int w = 128, h = 128;

    public double fps = 20;

    public Graphics2D g;

    public Animation() {
    }

    public Animation(int w, int h) {
      this.h = h;
      this.w = w;
    }

    public void setSize(int w, int h) {
      this.w = w;
      this.h = h;
    }

    public void setGraphics(Graphics2D g) {
      this.g = g;
    }

    public void start() {
    }

    public void paint() {
    }

    public void nextFrame() {
    }

    public BufferedImage toImage() {
      var img = whiteImage(w, h);
      setGraphics(createGraphics(img));
      paint();
      return img;
    }
  }

  public interface IHasTokenRangeWithSrc {

    public void setTokenRangeWithSrc(TokenRangeWithSrc src);

    public TokenRangeWithSrc tokenRangeWithSrc();
  }

  static public class FPSCounter {

    public Timestamp started = new Timestamp();

    public double counter;

    synchronized public void inc() {
      counter++;
    }

    synchronized public double get() {
      return doubleRatio(counter, secondsSinceStart());
    }

    public double secondsSinceStart() {
      return elapsedSeconds(started);
    }

    synchronized public void reset() {
      started = tsNow();
      counter = 0;
    }
  }

  static public class SourceTriggeredStream<A> extends Meta {

    public DoneFlag ended = new DoneFlag(true);

    volatile public A lastElement;

    public AtomicLong elementCount = new AtomicLong();

    transient public List<IVF1<A>> onNewElement;

    public SourceTriggeredStream<A> onNewElement(IVF1<A> f) {
      onNewElement = syncAddOrCreate(onNewElement, f);
      return this;
    }

    public SourceTriggeredStream<A> removeNewElementListener(IVF1<A> f) {
      main.remove(onNewElement, f);
      return this;
    }

    public void newElement(A a) {
      lastElement = a;
      inc(elementCount);
      pcallFAll(onNewElement, a);
    }

    public void onNewElement(Runnable r) {
      onNewElement(runnableToIVF1(r));
    }

    public A get() {
      return lastElement;
    }

    public long elementCount() {
      return elementCount.get();
    }

    public void end() {
      ended.raise();
    }

    public boolean ended() {
      return ended.isUp();
    }

    public void catchError(Runnable r) {
      main.catchError(ended, r);
    }

    public void directlyFeedInto(Consumer<A> consumer) {
      if (consumer != null)
        onNewElement(a -> consumer.accept(a));
    }
  }

  static public interface G22MasterStuff {

    public void switchDatabase(File dir);
  }

  static public class OnePath {

    public ByteBuffer steps = new ByteBuffer();

    static final public Pt[] directions = { pt(0, 0), pt(-1, -1), pt(0, -1), pt(1, -1), pt(1, 0), pt(1, 1), pt(0, 1), pt(-1, 1), pt(-1, 0) };

    public OnePath() {
    }

    public OnePath(String path) {
      int n = l(path);
      steps.allocate(n);
      for (int i = 0; i < n; i++) steps.add(parseDigit(path, i));
    }

    public OnePath(Iterable<Pt> points, boolean close) {
      var it = iterator(points);
      if (empty(it))
        return;
      Pt firstPoint = it.next(), p = firstPoint;
      while (it.hasNext()) {
        Pt p2 = it.next();
        steps.add(ptToDigit(ptMinus(p2, p)));
        p = p2;
      }
      if (close)
        steps.add(ptToDigit(ptMinus(firstPoint, p)));
    }

    final public int length() {
      return size();
    }

    public int size() {
      return steps.size();
    }

    public String toString() {
      return singleDigitBytesToString(steps);
    }

    public IterableIterator<Pt> pointIterator() {
      return pointIterator(origin());
    }

    public IterableIterator<Pt> pointIterator(Pt startPt) {
      return new IterableIterator<Pt>() {

        public int i = 0, n = length();

        public Pt p = startPt;

        public boolean hasNext() {
          return i <= n;
        }

        public Pt next() {
          var p = this.p;
          if (i < n)
            this.p = translatePt(this.p, getStepAsPt(i));
          ++i;
          return p;
        }
      };
    }

    public Pt getStepAsPt(int i) {
      return directions[steps.get(i)];
    }

    static public int ptToDigit(Pt p) {
      return p.y < 0 ? p.x < 0 ? 1 : p.x == 0 ? 2 : 3 : p.y == 0 ? p.x < 0 ? 8 : p.x == 0 ? 0 : 4 : p.x < 0 ? 7 : p.x == 0 ? 6 : 5;
    }

    public Pt drift() {
      return last(pointIterator());
    }
  }

  static public class GazelleVScript implements IFieldsToList {

    public String text;

    public GazelleVScript() {
    }

    public GazelleVScript(String text) {
      this.text = text;
    }

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

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

    public List<String> tok;

    static public String helpText = "Gazelle 22 \"Linear Script\"\r\n--------------------------\r\n\r\n\"Linear script\" is one of Gazelle 22's two scripting languages. It is the simpler (and older) one of the two with limited use.\r\n\r\n-You just write one line\r\n-Separate commands with spaces\r\n-The language is case-insensitive\r\n-You can add comments like in Java with /* */ or //\r\n\r\nCommands are:\r\n\r\n1p, 2p etc: Scale image down to x pixels\r\n1c, 2c, ..., 256c: Reduce gray scale levels\r\n1w, 2w etc: Scale image width only to x pixels\r\nstruct: show object structure\r\nniceStruct: show object structure indented\r\nrasters: reproduce horizontal bars\r\nclassName: show type of object on stack\r\nq1...q4: select quadrant\r\noriginal: show input image in color\r\n";

    public class Sequence {

      public Map<String, Object> vars = new HashMap();
    }

    public class Run implements Steppable {

      public ListAndIndex<String> ptr;

      public String token;

      public Stack stack = new Stack();

      final public Run setInputImage(IBWIntegralImage inputImage) {
        return inputImage(inputImage);
      }

      public Run inputImage(IBWIntegralImage inputImage) {
        this.inputImage = inputImage;
        return this;
      }

      final public IBWIntegralImage getInputImage() {
        return inputImage();
      }

      public IBWIntegralImage inputImage() {
        return inputImage;
      }

      public IBWIntegralImage inputImage;

      public IBWIntegralImage integralImage;

      final public Run setBwImage(BWImage bwImage) {
        return bwImage(bwImage);
      }

      public Run bwImage(BWImage bwImage) {
        this.bwImage = bwImage;
        return this;
      }

      final public BWImage getBwImage() {
        return bwImage();
      }

      public BWImage bwImage() {
        return bwImage;
      }

      public BWImage bwImage;

      public Run setIntegralImage(IBWIntegralImage ii) {
        push(integralImage = ii);
        return this;
      }

      public Run() {
        parse();
        ptr = new ListAndIndex(tok, 1);
      }

      public void push(Object o) {
        stack.add(o);
      }

      public Object value() {
        return last(stack);
      }

      public boolean step() {
        token = ptr.get();
        if (token == null)
          return false;
        next();
        if (isInteger(token)) {
          int i = parseInt(token);
          token = tpp();
          if (is("p"))
            scaleToHeight(i);
          else if (is("c"))
            posterize(i);
          else if (is("w"))
            scaleWidthOnly(i);
          else
            warn("Unknown token: " + token);
        } else if (is("rasters"))
          push(reproduceRasterBars(bwIntegralImage()));
        else if (is("struct"))
          push(struct(value()));
        else if (is("niceStruct"))
          push(sfuIndent(value()));
        else if (is("className"))
          push(className(value()));
        else if (is("borderImage"))
          push(bwImage = gazelle22_borderImage(bwImage));
        else if (is("gradientImage"))
          push(bwImage = new Gazelle22_GradientImage(bwImage).get());
        else if (is("q1"))
          clip(0, .5, 0, .5);
        else if (is("q2"))
          clip(.5, 1, 0, .5);
        else if (is("q3"))
          clip(0, .5, .5, 1);
        else if (is("q4"))
          clip(.5, 1, .5, 1);
        else if (is("original"))
          push(toBufferedImage(inputImage));
        else {
          warn("Unknown token: " + token);
        }
        return true;
      }

      public boolean is(String t) {
        return eqic(token, t);
      }

      public String tpp() {
        var token = ptr.get();
        next();
        return token;
      }

      public void next() {
        if (!ptr.atEnd())
          ptr = ptr.plus(2);
      }

      public void scaleToHeight(int pixelRows) {
        pixelRows = min(pixelRows, 512);
        if (integralImage == null) {
          warn("No integral image to scale down");
          return;
        }
        push(bwImage = scaledBWImageFromBWIntegralImage_withMeta_height(pixelRows, integralImage));
      }

      public void posterize(int colors) {
        colors = clamp(colors, 2, 256);
        if (bwImage == null) {
          warn("No image to posterize");
          return;
        } else
          push(bwImage = posterizeBWImage_withMeta(colors, bwImage));
      }

      public IBWIntegralImage bwIntegralImage() {
        Object val = value();
        if (val instanceof IBWIntegralImage)
          return ((IBWIntegralImage) val);
        if (val instanceof BWImage) {
          var ii = main.bwIntegralImage((BWImage) val);
          setIntegralImage(ii);
          return ii;
        }
        throw fail("Not an image on stack");
      }

      public void scaleWidthOnly(int w) {
        var ii = bwIntegralImage();
        push(bwImage = scaledBWImageFromBWIntegralImage_withMeta(ii, w, ii.getHeight()));
      }

      public void clip(double x1, double x2, double y1, double y2) {
        Object val = value();
        if (val instanceof IBWIntegralImage) {
          int w = ((IBWIntegralImage) val).getWidth(), h = ((IBWIntegralImage) val).getHeight();
          Rect r = toRect_round(scaleRect(w, h, doubleRectFromPoints(x1, y1, x2, y2)));
          setIntegralImage(new IIBWVirtualClip(((IBWIntegralImage) val), r));
        } else if (val instanceof BWImage)
          throw todo();
        else
          throw fail("Not an image on stack");
      }

      public Object result() {
        return last(stack);
      }

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

    public void parse() {
      if (tok == null)
        tok = javaTok(text);
    }
  }

  static public class LongBuffer implements Iterable<Long>, ILongQueue {

    public long[] data;

    public int size;

    public LongBuffer() {
    }

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

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

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

    public void allocate(int n) {
      data = resizeLongArray(data, max(n, size()));
    }

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

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

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

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

    public void reset() {
      size = 0;
    }

    public void clear() {
      reset();
    }

    public int size() {
      return size;
    }

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

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

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

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

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

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

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

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

        public int i = 0;

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

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

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

    public long poll() {
      return size == 0 ? -1 : data[--size];
    }
  }

  static abstract public class DynamicStack extends JPanel {

    public int spacing = 10;

    public boolean useFiller = false;

    public DynamicStack() {
      this(true);
    }

    public DynamicStack(boolean useFiller) {
      super(new GridBagLayout());
      this.useFiller = useFiller;
      _addFiller();
    }

    abstract public GridBagConstraints _componentConstraints();

    abstract public GridBagConstraints _fillerConstraints();

    public void _addFiller() {
      if (useFiller)
        add(jrigid(), _fillerConstraints());
    }

    public void addComponent(final Component c) {
      addComponents(ll(c));
    }

    public void addComponents(final Collection<? extends Component> l) {
      {
        swing(() -> {
          for (Component c : unnull(l)) add(c, _componentConstraints(), getComponentCount() - (useFiller ? 1 : 0));
          revalidate();
        });
      }
    }

    public void setComponents(Collection<Component> l) {
      removeAll();
      _addFiller();
      addComponents(l);
    }

    public void clearComponents() {
      setComponents(null);
    }

    public int numComponents() {
      return countComponents() - 1;
    }

    public List<Component> components() {
      return dropLast(loadableUtils.utils.getComponents(this));
    }

    public DynamicStack spacing(int n) {
      spacing = n;
      return this;
    }

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

  static public class ScoredStringSearcher extends ScoredSearcher_stable<String> {

    public ScoredStringSearcher() {
    }

    public ScoredStringSearcher(String query, Object... __) {
      super(query);
    }

    final public void add(String s) {
      put(s);
    }

    public void put(String s) {
      put(s, s);
    }

    public void addAll(Iterable<String> l) {
      for (var s : unnullForIteration(l)) add(s);
    }

    public void addAll(String... l) {
      addAll(asList(l));
    }
  }

  static public class FastRegions_BWImage implements Runnable, IImageRegions<BWImage>, IFieldsToList {

    public BWImage image;

    public FastRegions_BWImage() {
    }

    public FastRegions_BWImage(BWImage image) {
      this.image = image;
    }

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

    public int w, h, runner;

    final public int getSize() {
      return size();
    }

    public int size() {
      return size;
    }

    public int size;

    public IntBuffer stack = new IntBuffer();

    public int[] regionMatrix;

    public IntBuffer regionPixels = new IntBuffer();

    public IntBuffer regionFirstPixel = new IntBuffer();

    public IntBuffer regionSize = new IntBuffer();

    public IntBuffer regionBounds = new IntBuffer();

    public List<IntBuffer> regionsBySize = new ArrayList();

    public int regionCounter;

    public boolean verbose = false;

    public double regionStep = .1;

    public int x(int pos) {
      return pos % w;
    }

    public int y(int pos) {
      return pos / w;
    }

    public int pos(int x, int y) {
      return y * w + x;
    }

    public Pt pt(int pos) {
      return new Pt(x(pos), y(pos));
    }

    public boolean validPos(int x, int y) {
      return x >= 0 && y >= 0 && x < w && y < h;
    }

    public int getColor(int pos) {
      return image.getInt(x(pos), y(pos));
    }

    public FastRegions_BWImage(BufferedImage img) {
      this(toBWImage(img));
    }

    public void run() {
      try {
        w = image.getWidth();
        h = image.getHeight();
        size = w * h;
        regionMatrix = new int[size];
        {
          if (regionFirstPixel != null)
            regionFirstPixel.add(0);
        }
        {
          if (regionSize != null)
            regionSize.add(0);
        }
        {
          if (regionPixels != null)
            regionPixels.setSize(size);
        }
        while (runner < size) {
          if (regionMatrix[runner] == 0) {
            int region = ++regionCounter;
            {
              if (regionFirstPixel != null)
                regionFirstPixel.add(regionPixels != null ? l(regionPixels) : runner);
            }
            stack.add(runner);
            int color = getColor(runner);
            int rsize = 0, x1 = w, y1 = h, x2 = 0, y2 = 0;
            while (nempty(stack)) {
              int pos = stack.popLast();
              if (regionMatrix[pos] != 0)
                continue;
              if (getColor(pos) != color)
                continue;
              regionMatrix[pos] = region;
              ++rsize;
              {
                if (regionPixels != null)
                  regionPixels.add(pos);
              }
              int x = x(pos), y = y(pos);
              if (x < x1)
                x1 = x;
              if (x > x2)
                x2 = x;
              if (y < y1)
                y1 = y;
              if (y > y2)
                y2 = y;
              if (x > 0)
                stack.add(pos - 1);
              if (x < w - 1)
                stack.add(pos + 1);
              if (y > 0)
                stack.add(pos - w);
              if (y < h - 1)
                stack.add(pos + w);
            }
            {
              if (regionSize != null)
                regionSize.add(rsize);
            }
            {
              if (regionBounds != null)
                regionBounds.addAll(x1, y1, x2 + 1, y2 + 1);
            }
            if (regionsBySize != null) {
              int iBucket = dualLog(rsize);
              var buffer = listGetOrCreate(regionsBySize, iBucket, () -> new IntBuffer());
              buffer.add(region);
            }
          }
          ++runner;
        }
      } catch (Exception __e) {
        throw rethrow(__e);
      }
    }

    public IBWImage regionsImage() {
      return iBWImageFromFunction((x, y) -> {
        var region = regionMatrix[pos(x, y)];
        return ((region - 1) * regionStep) % (1.0 + regionStep - 0.0001);
      }, w, h);
    }

    final public int nRegions() {
      return regionCount();
    }

    public int regionCount() {
      return regionCounter;
    }

    abstract public class RegionIterator {

      public int pos;

      abstract public boolean next();

      public int pos() {
        return pos;
      }

      public int x() {
        return FastRegions_BWImage.this.x(pos);
      }

      public int y() {
        return FastRegions_BWImage.this.y(pos);
      }
    }

    public class FloodRegionIterator extends RegionIterator {

      public int region;

      public IntBuffer stack = new IntBuffer();

      public BitSet seen = new BitSet(size);

      public FloodRegionIterator(int region) {
        this.region = region;
        int pos = regionFirstPixel.get(region);
        printVars("region", region, "pos", pos);
        seen.set(pos);
        stack.add(pos);
      }

      public boolean next() {
        if (empty(stack))
          return false;
        pos = stack.popLast();
        int x = x(), y = y();
        if (x > 0)
          tryPosition(pos - 1);
        if (x < w - 1)
          tryPosition(pos + 1);
        if (y > 0)
          tryPosition(pos - w);
        if (y < h - 1)
          tryPosition(pos + w);
        return true;
      }

      final public void tryPosition(int p) {
        if (!seen.get(p) && regionMatrix[p] == region) {
          seen.set(p);
          stack.add(p);
        }
      }
    }

    public class CachedRegionIterator extends RegionIterator {

      public int i, to;

      public CachedRegionIterator(int region) {
        i = regionFirstPixel.get(region);
        to = region + 1 < l(regionFirstPixel) ? regionFirstPixel.get(region + 1) : l(regionPixels);
      }

      public boolean next() {
        if (i >= to)
          return false;
        pos = regionPixels.get(i++);
        return true;
      }
    }

    public int regionSize(int iRegion) {
      return regionSize.get(iRegion);
    }

    final public Pt firstPixel(int iRegion) {
      return samplePixel(iRegion);
    }

    public Pt samplePixel(int iRegion) {
      return pt(firstPixelPos(iRegion));
    }

    public int firstPixelPos(int iRegion) {
      int i = regionFirstPixel.get(iRegion);
      return regionPixels != null ? regionPixels.get(i) : i;
    }

    public boolean inRegion(int iRegion, int x, int y) {
      return validPos(x, y) && regionMatrix[pos(x, y)] == iRegion;
    }

    public Rect regionBounds(int iRegion) {
      return rectFromPoints(regionBounds.get((iRegion - 1) * 4), regionBounds.get((iRegion - 1) * 4 + 1), regionBounds.get((iRegion - 1) * 4 + 2), regionBounds.get((iRegion - 1) * 4 + 3));
    }

    public int regionAt(Pt p) {
      return regionAt(p.x, p.y);
    }

    public int regionAt(int x, int y) {
      return !validPos(x, y) ? 0 : regionMatrix[pos(x, y)];
    }

    public int regionAt(int pos) {
      return regionMatrix[pos];
    }

    public RegionIterator regionIterator(int iRegion) {
      return regionPixels != null ? new CachedRegionIterator(iRegion) : new FloodRegionIterator(iRegion);
    }

    public List<Pt> regionPixels(int iRegion) {
      var it = regionIterator(iRegion);
      List<Pt> l = new ArrayList();
      while (it.next()) l.add(new Pt(it.x(), it.y()));
      return l;
    }

    public void collectFirstPixels() {
    }

    public void collectBounds() {
    }

    public Matrix<Boolean> regionBitMatrix(int iRegion) {
      return new AbstractMatrix<Boolean>(w, h) {

        public Boolean get(int x, int y) {
          return inRegion(iRegion, x, y);
        }
      };
    }

    public void markRegionInPixelArray(int[] pixels, int iRegion, int rgba) {
      if (iRegion <= 0)
        return;
      for (int i = 0; i < l(pixels); i++) if (regionAt(i) == iRegion)
        pixels[i] = rgba;
    }

    public List<Integer> regionIndices() {
      return virtualCountList(1, nRegions() + 1);
    }

    public IterableIterator<Integer> regionsRoughlyByDecreasingSize() {
      return nestedIterator(countIterator_inclusive_backwards(regionsBySize.size() - 1, 0), iBucket -> iterator(regionsBySize.get(iBucket)));
    }

    final public IImageRegion<BWImage> get(int iRegion) {
      return getRegion(iRegion);
    }

    public IImageRegion<BWImage> getRegion(int iRegion) {
      return new ImageRegion(iRegion);
    }

    public List<IImageRegion<BWImage>> regions() {
      return listFromFunction(i -> getRegion(i + 1), nRegions());
    }

    public class ImageRegion implements IImageRegion<BWImage>, IFieldsToList {

      public int iRegion;

      public ImageRegion() {
      }

      public ImageRegion(int iRegion) {
        this.iRegion = iRegion;
      }

      public boolean equals(Object o) {
        if (!(o instanceof ImageRegion))
          return false;
        ImageRegion __0 = (ImageRegion) o;
        return iRegion == __0.iRegion;
      }

      public int hashCode() {
        int h = -494554097;
        h = boostHashCombine(h, _hashCode(iRegion));
        return h;
      }

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

      public BWImage image() {
        return image;
      }

      public Object creator() {
        return FastRegions_BWImage.this;
      }

      public int indexInCreator() {
        return iRegion;
      }

      public Rect bounds() {
        return regionBounds(iRegion);
      }

      public int numberOfPixels() {
        return regionSize(iRegion);
      }

      public Pt firstPixel() {
        return pt(firstPixelPos());
      }

      public int firstPixelPos() {
        return FastRegions_BWImage.this.firstPixelPos(iRegion);
      }

      public Iterator<Pt> pixelIterator() {
        var it = regionIterator(iRegion);
        return iteratorFromFunction(() -> it.next() ? pt(it.pos()) : null);
      }

      public boolean contains(int x, int y) {
        return inRegion(iRegion, x, y);
      }

      public RGB color() {
        return rgbFromGrayscale(brightness());
      }

      public int brightness() {
        return getColor(firstPixelPos());
      }

      public String toString() {
        return renderRecordVars("Region", "brightness", brightness(), "color", color(), "pixels", numberOfPixels(), "bounds", bounds());
      }
    }
  }

  static public class DoneFlag extends Flag {

    transient volatile public Object error;

    transient public boolean printErrors = false;

    public DoneFlag() {
    }

    public DoneFlag(boolean printErrors) {
      this.printErrors = printErrors;
    }

    public void done() {
      raise();
    }

    final public void setError(Object error) {
      done(error);
    }

    public void done(Object error) {
      this.error = error;
      if (printErrors)
        printStackTrace_gen(error);
      raise();
    }

    public boolean hasError() {
      return error != null;
    }

    public boolean isDone() {
      return isUp();
    }
  }

  static public class CharInToken implements IFieldsToList {

    static final public String _fieldOrder = "tok iTok iChar";

    public List<String> tok;

    public int iTok;

    public int iChar;

    public CharInToken() {
    }

    public CharInToken(List<String> tok, int iTok, int iChar) {
      this.iChar = iChar;
      this.iTok = iTok;
      this.tok = tok;
    }

    public boolean equals(Object o) {
      if (!(o instanceof CharInToken))
        return false;
      CharInToken __1 = (CharInToken) o;
      return eq(tok, __1.tok) && iTok == __1.iTok && iChar == __1.iChar;
    }

    public int hashCode() {
      int h = 2081721214;
      h = boostHashCombine(h, _hashCode(tok));
      h = boostHashCombine(h, _hashCode(iTok));
      h = boostHashCombine(h, _hashCode(iChar));
      return h;
    }

    public Object[] _fieldsToList() {
      return new Object[] { tok, iTok, iChar };
    }

    public String token() {
      return get(tok, iTok);
    }

    public String toString() {
      return renderRecordVars("CharInToken", "iTok", iTok, "iChar", iChar, "token", token());
    }
  }

  static public class LineAndColumn {

    public int line, col;

    public LineAndColumn(int line, int col) {
      this.col = col;
      this.line = line;
    }

    transient public IF1<Integer, String> getLineText;

    public String getLineText(int line) {
      return getLineText != null ? getLineText.get(line) : getLineText_base(line);
    }

    final public String getLineText_fallback(IF1<Integer, String> _f, int line) {
      return _f != null ? _f.get(line) : getLineText_base(line);
    }

    public String getLineText_base(int line) {
      return null;
    }

    public String toString() {
      return "Line " + n2(line) + ", col " + n2(col);
    }
  }

  static public class ByteBuffer implements Iterable<Byte> {

    public byte[] data;

    public int size;

    public ByteBuffer() {
    }

    public ByteBuffer(int size) {
      if (size != 0)
        data = new byte[size];
    }

    public ByteBuffer(Iterable<Byte> l) {
      this(l(l));
      addAll(l);
    }

    public ByteBuffer(byte[] data) {
      this.data = data;
      size = l(data);
    }

    public void add(int i) {
      add((byte) i);
    }

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

    public void allocate(int n) {
      data = resizeByteArray(data, max(n, size()));
    }

    public void addAll(Iterable<Byte> l) {
      if (l != null)
        for (byte i : l) add(i);
    }

    final public byte[] toByteArray() {
      return toArray();
    }

    public byte[] toArray() {
      return size == 0 ? null : resizeByteArray(data, size);
    }

    public List<Byte> toList() {
      return byteArrayToList(data, 0, size);
    }

    public List<Byte> asVirtualList() {
      return new RandomAccessAbstractList<Byte>() {

        public int size() {
          return size;
        }

        public Byte get(int i) {
          return ByteBuffer.this.get(i);
        }

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

    public void reset() {
      size = 0;
    }

    public void clear() {
      reset();
    }

    public int size() {
      return size;
    }

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

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

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

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

    public byte popFirst() {
      if (size == 0)
        throw fail("empty buffer");
      byte b = data[0];
      arraycopy(data, 1, 0, --size);
      return b;
    }

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

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

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

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

        public int i = 0;

        public boolean hasNext() {
          return i < size;
        }

        public Byte next() {
          return data[i++];
        }
      };
    }

    public void trimToSize() {
      data = resizeByteArray(data, size);
    }

    public int indexOf(byte b) {
      for (int i = 0; i < size; i++) if (data[i] == b)
        return i;
      return -1;
    }

    public byte[] subArray(int start, int end) {
      return subByteArray(data, start, min(end, size));
    }
  }

  static public class Stringifier_ToString implements IStringifier {

    public String toString(Object o) {
      return str(o);
    }
  }

  static public class DeQ extends Q {

    public DeQ() {
      q = new LinkedList();
    }

    public void addFirst(Object r) {
      ((Deque) q).addFirst(toRunnable(r));
      _trigger();
    }
  }

  public interface IPartialStringifier<A> {

    public String toStringOpt(A o);
  }

  static public class ListAndIndex<A> implements IFieldsToList {

    static final public String _fieldOrder = "list idx";

    public List<A> list;

    public int idx;

    public ListAndIndex() {
    }

    public ListAndIndex(List<A> list, int idx) {
      this.idx = idx;
      this.list = list;
    }

    public boolean equals(Object o) {
      if (!(o instanceof ListAndIndex))
        return false;
      ListAndIndex __1 = (ListAndIndex) o;
      return eq(list, __1.list) && idx == __1.idx;
    }

    public int hashCode() {
      int h = 276903961;
      h = boostHashCombine(h, _hashCode(list));
      h = boostHashCombine(h, _hashCode(idx));
      return h;
    }

    public Object[] _fieldsToList() {
      return new Object[] { list, idx };
    }

    public boolean atEnd() {
      return idx >= l(list);
    }

    public A get() {
      return _get(list, idx);
    }

    public int size() {
      return l(list);
    }

    public String toString() {
      return subList(list, 0, idx) + ", then " + subList(list, idx);
    }

    public ListAndIndex<A> plus(int ofs) {
      return new ListAndIndex(list, idx + ofs);
    }

    public List<A> list() {
      return list;
    }

    final public int idx() {
      return index();
    }

    public int index() {
      return idx;
    }
  }

  static public class TokenRange extends IntRange {

    public TokenRange() {
    }

    public TokenRange(int start, int end) {
      this.end = end;
      this.start = start;
    }
  }

  static public class IIBWVirtualClip extends Meta implements IBWIntegralImage {

    public IBWIntegralImage fullImage;

    public int x1, y1, w, h;

    public IIBWVirtualClip() {
    }

    public IIBWVirtualClip(IBWIntegralImage fullImage, Rect r) {
      this(fullImage, r.x, r.y, r.w, r.h);
    }

    public IIBWVirtualClip(IBWIntegralImage fullImage, int x1, int y1, int w, int h) {
      this.h = h;
      this.w = w;
      this.y1 = y1;
      this.x1 = x1;
      this.fullImage = fullImage;
      optimize();
    }

    public int getWidth() {
      return w;
    }

    public int getHeight() {
      return h;
    }

    public int getIIValue(int x, int y) {
      return fullImage.getIIValue(x + x1, y + y1);
    }

    public double getIIValue(double x, double y) {
      return fullImage.getIIValue(x + x1, y + y1);
    }

    public BufferedImage getBufferedImage() {
      return clipBufferedImage(fullImage.getBufferedImage(), x1, y1, w, h);
    }

    public void optimize() {
      if (fullImage instanceof IIBWVirtualClip) {
        x1 += ((IIBWVirtualClip) fullImage).x1;
        y1 += ((IIBWVirtualClip) fullImage).y1;
        fullImage = ((IIBWVirtualClip) fullImage).fullImage;
      }
    }
  }

  static public class VarMatches extends WrappedMap<String, String> {

    public VarMatches() {
      super(new LinkedHashMap());
    }

    public VarMatches(Map<String, String> map) {
      this();
      main.putAll(this, map);
    }
  }

  static public interface ISleeper extends AutoCloseable {

    public void doLater(long targetSysTime, Runnable r);
  }

  abstract static public class ImageSurfaceMouseHandler extends MouseAdapter implements AutoCloseable {

    public ImageSurface is;

    public void register(ImageSurface is) {
      this.is = is;
      is.tools.add(this);
      is.addMouseListener(this);
      is.addMouseMotionListener(this);
    }

    public void close() {
      try {
        if (is == null)
          return;
        is.tools.remove(this);
        is.removeMouseListener(this);
        is.removeMouseMotionListener(this);
        is = null;
      } catch (Exception __e) {
        throw rethrow(__e);
      }
    }

    public Pt getPt(MouseEvent e) {
      return toPt(getPoint(e));
    }

    public Point getPoint(MouseEvent e) {
      return new Point((int) (e.getX() / is.getZoomX()), (int) (e.getY() / is.getZoomY()));
    }
  }

  static public class ScoredSearcher_stable<A> {

    public int maxResults = 1000;

    public boolean returnAll = false;

    public List<String> preparedTerms;

    public MultiMap<Double, A> byScore = descTreeMultiMap();

    public ScoredSearcher_stable() {
    }

    public ScoredSearcher_stable(String query, Object... __) {
      maxResults = optPar("maxResults", __, maxResults);
      setQuery(query);
    }

    public void setQuery(String query) {
      preparedTerms = scoredSearch_prepare(query);
    }

    public void put(A object, String s) {
      putScored(object, score(s));
    }

    public void putScored(A object, double score) {
      if (score != 0)
        byScore.add(score, object);
    }

    public void put(A object, Collection<String> fields) {
      add(object, scoreFields(fields));
    }

    public void putWithWeights(A object, Collection<Pair<String, Double>> fields) {
      scoredSearch_scoreWeighted2(fields, preparedTerms);
    }

    public int scoreFields(Collection<String> fields) {
      return scoredSearch_score(fields, preparedTerms);
    }

    public int score(String text) {
      return returnAll ? 1 : scoredSearch_score(text, preparedTerms);
    }

    public void add(A object) {
      put(object, str(object));
    }

    public void add(A object, Collection<String> fields) {
      put(object, fields);
    }

    public void put(A object, double score) {
      add(object, score);
    }

    public void add(A object, double score) {
      putScored(object, score);
    }

    public List<A> get() {
      return pairsB(takeFirst(maxResults, multiMapPairIterator(byScore)));
    }

    public List<A> get_transformListWithinScore(IF1<List<A>, List<A>> f) {
      return pairsB(takeFirst(maxResults, multiMapPairIterator_transformValueList(byScore, f)));
    }

    public List<Scored<A>> withScores() {
      return map(takeFirst(maxResults, multiMapPairIterator(byScore)), p -> new Scored(p.b, p.a));
    }

    public A best() {
      return firstValue(byScore);
    }
  }

  static public class WrappedMap<A, B> extends AbstractMap<A, B> {

    public Map<A, B> map;

    public WrappedMap() {
    }

    public WrappedMap(Map<A, B> map) {
      this.map = map;
    }

    public B get(Object key) {
      return map.get(key);
    }

    public B put(A key, B value) {
      return map.put(key, value);
    }

    public boolean containsKey(Object key) {
      return map.containsKey(key);
    }

    public Set<Map.Entry<A, B>> entrySet() {
      return map.entrySet();
    }
  }

  static public interface ILongQueue {

    public boolean isEmpty();

    public void add(long element);

    public long poll();
  }

  static public <A extends IHasChangeListeners, B> SimpleLiveValue<B> liveValue_hasChangeListeners(A object, IF0<B> getter) {
    return liveValue_hasChangeListeners(object, null, getter);
  }

  static public <A extends IHasChangeListeners, B> SimpleLiveValue<B> liveValue_hasChangeListeners(A object, Class<B> type, IF0<B> getter) {
    return liveValue_hasChangeListeners(object, null, getter, null);
  }

  static public <A extends IHasChangeListeners, B> SimpleLiveValue<B> liveValue_hasChangeListeners(A object, IF0<B> getter, IVF1<B> setter) {
    return liveValue_hasChangeListeners(object, null, getter, setter);
  }

  static public <A extends IHasChangeListeners, B> SimpleLiveValue<B> liveValue_hasChangeListeners(A object, Class<B> type, IF0<B> getter, IVF1<B> setter) {
    SimpleLiveValue<B> value = new SimpleLiveValue<>(type, getter.get());
    addWeakChangeListener(object, value, val -> val.set(getter.get()));
    value.onChange(() -> {
      {
        if (setter != null)
          setter.get(value.get());
      }
    });
    return value;
  }

  static public <A extends JComponent> A awtEvery(A component, long delay, Object r) {
    swingEvery(component, delay, r);
    return component;
  }

  static public <A extends JComponent> A awtEvery(A component, long delay, long firstDelay, Object r) {
    swingEvery(component, delay, firstDelay, r);
    return component;
  }

  static public void awtEvery(RootPaneContainer frame, long delay, Object r) {
    swingEvery(frame, delay, r);
  }

  static public <A extends JComponent> A awtEvery(A component, double delaySeconds, Object r) {
    return awtEvery(component, toMS(delaySeconds), r);
  }

  static public Map<BufferedImage, Object> createGraphics_modulators = synchroIdentityHashMap();

  static public Graphics2D createGraphics(BufferedImage img) {
    Graphics2D g = img.createGraphics();
    Object mod = createGraphics_modulators.get(img);
    if (mod != null)
      callF(mod, g);
    return g;
  }

  static public void createGraphics_modulate(BufferedImage img, Object mod) {
    mapPut2(createGraphics_modulators, img, mod);
  }

  static public BWIntegralImage bwIntegralImage_withMeta(BufferedImage img) {
    return bwIntegralImage_withMeta(img, null);
  }

  static public BWIntegralImage bwIntegralImage_withMeta(BufferedImage img, Decolorizer decolorizer) {
    return setMetaSrc(bwIntegralImage(img, decolorizer), img);
  }

  static public BWIntegralImage bwIntegralImage_withMeta(BWImage img) {
    return setMetaSrc(bwIntegralImage(img), img);
  }

  static public JPanel centerAndSouthWithMargin(Component c, Component s) {
    return centerAndSouth(c, withTopMargin(s));
  }

  static public JPanel centerAndSouthWithMargin(int margin, Component c, Component s) {
    return centerAndSouth(c, withTopMargin(margin, s));
  }

  static public JCheckBox liveValueCheckBox(String text, SimpleLiveValue<Boolean> lv) {
    return jLiveValueCheckBox(text, lv);
  }

  static public ImageSurface pixelatedImageSurface() {
    var is = imageSurface();
    imageSurface_pixelated(is);
    return is;
  }

  static public ImageSurface pixelatedImageSurface(MakesBufferedImage img) {
    return pixelatedImageSurface(toBufferedImage(img));
  }

  static public ImageSurface pixelatedImageSurface(BufferedImage img) {
    var is = pixelatedImageSurface();
    is.setImage(img);
    return is;
  }

  static public BufferedImage toBufferedImage(Object o) {
    return toBufferedImageOpt(o);
  }

  static public <A> A assertNotNull(A a) {
    assertTrue(a != null);
    return a;
  }

  static public <A> A assertNotNull(String msg, A a) {
    assertTrue(msg, a != null);
    return a;
  }

  static public boolean sameFile(File a, File b) {
    try {
      return a == null ? b == null : b != null && eq(a.getCanonicalPath(), b.getCanonicalPath());
    } catch (Exception __e) {
      throw rethrow(__e);
    }
  }

  static public <A> A shallowClone(A o) {
    return (A) shallowClone_impl(o);
  }

  static public <A> A shallowClone(A o, A emptyClone) {
    return copyFields(o, emptyClone);
  }

  static public Object shallowClone_impl(Object o) {
    if (o == null)
      return o;
    if (o instanceof List)
      return cloneList((List) o);
    if (o instanceof Map)
      return cloneMap((Map) o);
    if (o instanceof String || o instanceof Number || o instanceof Boolean)
      return o;
    if (o instanceof Object[]) {
      Object[] l = (Object[]) o;
      return l.clone();
    }
    Class c = o.getClass();
    final Object clone = nuEmptyObject(c);
    copyFields(o, clone);
    return clone;
  }

  static public boolean bitMatrixRowEmpty(Matrix<Boolean> m, int y) {
    int w = m.getWidth();
    for (int x = 0; x < w; x++) if (m.get(x, y))
      return false;
    return true;
  }

  static public RuntimeException unimplemented() {
    throw fail("TODO");
  }

  static public RuntimeException unimplemented(String msg) {
    throw fail("TODO: " + msg);
  }

  static public RuntimeException unimplemented(Object obj) {
    throw fail("TODO: implement method in " + className(obj));
  }

  static public void desktopOpen(File f) {
    try {
      if (f != null) {
        print("desktopOpen: " + f2s(f));
        Desktop.getDesktop().open(f);
      }
    } catch (Exception __e) {
      throw rethrow(__e);
    }
  }

  static public int syncL(Collection l) {
    if (l == null)
      return 0;
    synchronized (collectionMutex(l)) {
      return l.size();
    }
  }

  static public int syncL(Map map) {
    if (map == null)
      return 0;
    synchronized (collectionMutex(map)) {
      return map.size();
    }
  }

  static public <A> List<A> syncL() {
    return syncList();
  }

  static public Class _run(String progID, String... args) {
    Class main = hotwire(progID);
    callMain(main, args);
    return main;
  }

  static public <A> List<A> syncGetAndClear(Collection<A> l) {
    return syncCloneAndClearList(l);
  }

  static public <A> A getWeakRef(Reference<A> ref) {
    return ref == null ? null : ref.get();
  }

  static public void cancelAndInterruptThread(Thread t) {
    if (t == null)
      return;
    cancelThread(t);
    t.interrupt();
  }

  static public int getWidth(Component c) {
    return c == null ? 0 : (int) swingCall(c, "getWidth");
  }

  static public int getHeight(Component c) {
    return c == null ? 0 : (int) swingCall(c, "getHeight");
  }

  static public Color getBackground(final Component c) {
    return c == null ? null : swing(new F0<Color>() {

      public Color get() {
        try {
          return c.getBackground();
        } catch (Exception __e) {
          throw rethrow(__e);
        }
      }

      public String toString() {
        return "return c.getBackground();";
      }
    });
  }

  static public FontMetrics componentFontMetrics(JComponent c) {
    Font font = getFont(c);
    return font == null ? null : swing(new F0<FontMetrics>() {

      public FontMetrics get() {
        try {
          return c.getFontMetrics(font);
        } catch (Exception __e) {
          throw rethrow(__e);
        }
      }

      public String toString() {
        return "return c.getFontMetrics(font);";
      }
    });
  }

  static public int idiv_ceil(int a, int b) {
    return (a + b - 1) / b;
  }

  static public int idiv_ceil(long a, long b) {
    return toInt_checked((a + b - 1) / b);
  }

  static public <A extends JComponent> A componentPopupMenuItem(A c, final String name, final Object action) {
    componentPopupMenu(c, new VF1<JPopupMenu>() {

      public void get(JPopupMenu menu) {
        try {
          addMenuItem(menu, name, action);
        } catch (Exception __e) {
          throw rethrow(__e);
        }
      }

      public String toString() {
        return "addMenuItem(menu, name, action);";
      }
    });
    return c;
  }

  static public void componentPopupMenuItem(JComponent c, final JMenuItem menuItem) {
    componentPopupMenu(c, new VF1<JPopupMenu>() {

      public void get(JPopupMenu menu) {
        try {
          addMenuItem(menu, menuItem);
        } catch (Exception __e) {
          throw rethrow(__e);
        }
      }

      public String toString() {
        return "addMenuItem(menu, menuItem);";
      }
    });
  }

  static public <A> List<A> asSyncList(Iterable<A> l) {
    return asSynchroList(l);
  }

  static public <A extends Component> A _revalidate(A c) {
    return revalidate(c);
  }

  static public void _revalidate(JFrame f) {
    revalidate(f);
  }

  static public void _revalidate(JInternalFrame f) {
    revalidate(f);
  }

  static public boolean endsWithNewLine(String s) {
    return endsWith(s, "\n");
  }

  static public String lines_rtrimIf(boolean rtrim, List<String> lines) {
    return rtrim ? lines_rtrim(lines) : lines(lines);
  }

  static public String copyTextToClipboard(Object _text) {
    String text = str(_text);
    StringSelection selection = new StringSelection(text);
    Toolkit.getDefaultToolkit().getSystemClipboard().setContents(selection, selection);
    vmBus_send("newClipboardContents", text);
    return text;
  }

  static public void catchError(DoneFlag doneFlag, Runnable r) {
    try {
      {
        if (r != null)
          r.run();
      }
    } catch (Throwable e) {
      doneFlag.setError(e);
    }
  }

  static public ScreenShotMeta shootScreenWithMeta(Rect bounds) {
    var timeRange = new TimestampRange().start(tsNow());
    ScreenShotMeta result = new ScreenShotMeta(timeRange, bounds, shootScreen2(bounds));
    timeRange.end(tsNow());
    result.image = cloneBufferedImageWithMetaSrc(result, result.image);
    return result;
  }

  static public void assertInstanceOf(Class type, Object o) {
    assertIsInstance(type, o);
  }

  static public Rect screenBounds_safe(int iScreen) {
    return screenBounds(min(iScreen, screenCount() - 1));
  }

  static public <A> Set<A> setWithNotify(final Runnable onChange) {
    return setWithNotify(new HashSet(), onChange);
  }

  static public <A> Set<A> setWithNotify(Set<A> set, final Runnable onChange) {
    return new NotifyingSet<A>(set) {

      public void change() {
        onChange.run();
      }
    };
  }

  static public MenuItem menuItem(String text, final Object r) {
    MenuItem mi = new MenuItem(text);
    mi.addActionListener(actionListener(r));
    return mi;
  }

  static public <A extends JComponent, B> A bindToolTipToTransformedLiveValue(IF1<B, Object> f, LiveValue<B> lv, A c) {
    bindLiveValueListenerToComponent(c, lv, new Runnable() {

      public void run() {
        try {
          setToolTipText(c, strOrNull(f.get(lv.get())));
        } catch (Exception __e) {
          throw rethrow(__e);
        }
      }

      public String toString() {
        return "setToolTipText(c, strOrNull(f.get(lv!)))";
      }
    });
    return c;
  }

  static public <A> JLabel simpleTransformedLiveValueLabel(IF1<A, Object> f, LiveValue<A> lv) {
    return bindJLabelToTransformedLiveValue(f, swing(() -> new JLabel()), lv);
  }

  static public MouseAdapter onMouseDown_anyButton(Component c, Runnable r) {
    return onMouseDown(c, runnableToIVF1(r));
  }

  static public MouseAdapter onMouseDown_anyButton(Component c, IVF1<MouseEvent> f) {
    return c == null || f == null ? null : swing(() -> {
      MouseAdapter ma = new MouseAdapter() {

        public void mousePressed(MouseEvent e) {
          f.get(e);
        }
      };
      c.addMouseListener(ma);
      return ma;
    });
  }

  static public int componentCount(Container c) {
    return numberOfChildren(c);
  }

  static public void addMenuItem(JPopupMenu menu, String text, Object action) {
    menu.add(jmenuItem(text, action));
  }

  static public void addMenuItem(JPopupMenu menu, JMenuItem menuItem) {
    if (menu != null && menuItem != null)
      menu.add(menuItem);
  }

  static public void addMenuItem(JMenu menu, String text, Object action) {
    menu.add(jmenuItem(text, action));
  }

  static public void addMenuItem(Menu menu, String text, Object action) {
    menu.add(menuItem(text, action));
  }

  static public void addMenuItem(JMenu menu, JMenuItem menuItem) {
    menu.add(menuItem);
  }

  static public void addMenuItem(JMenuBar menuBar, String text, Runnable action) {
    addMenuItem(menuBar, jmenuItem(text, action));
  }

  static public void addMenuItem(JMenuBar menuBar, JMenuItem menuItem) {
    addDirectMenuItem(menuBar, menuItem);
  }

  static public TitledBorder jRaisedSectionBorder(String title) {
    return swing(() -> {
      Border border = BorderFactory.createBevelBorder(BevelBorder.RAISED);
      return BorderFactory.createTitledBorder(border, title);
    });
  }

  static public void showPopupMenu(JPopupMenu menu, MouseEvent e) {
    if (menu != null && e != null)
      menu.show(e.getComponent(), e.getX(), e.getY());
  }

  static public Dimension dimensionPlus(int w, int h, Dimension d) {
    return d == null ? null : new Dimension(d.width + w, d.height + h);
  }

  static public void printVars(Object... params) {
    printVars_str(params);
  }

  static public Dimension maxDimension(Dimension a, Dimension b) {
    return a == null ? b : b == null ? a : new Dimension(max(a.width, b.width), max(a.height, b.height));
  }

  static public List syncMap(Object f, Map map) {
    return syncMap(map, f);
  }

  static public List syncMap(Map map, Object f) {
    return map(cloneLinkedHashMap(map), f);
  }

  static public <A, B> Map<A, B> syncMap() {
    return synchroHashMap();
  }

  static public <A, B> Map<A, B> syncMap(Map map) {
    return synchronizedMap(map);
  }

  static public DynamicObject dO(String className, Object... x) {
    return dynamicObject(className, x);
  }

  static public <A, B> B syncMapGetOrCreate(Map<A, B> map, A key, Class<? extends B> c) {
    return syncGetOrCreate(map, key, c);
  }

  static public <A, B> B syncMapGetOrCreate(Map<A, B> map, A key, Object f) {
    return syncGetOrCreate(map, key, f);
  }

  static public <A, B> B syncMapGetOrCreate(Class<? extends B> c, Map<A, B> map, A key) {
    return syncGetOrCreate(c, map, key);
  }

  static public <A, B> B syncMapGetOrCreate(Map<A, B> map, A key, IF0<B> f) {
    return syncGetOrCreate(map, key, f);
  }

  static public <A, B> Map<A, B> cloneMap(Map<A, B> map) {
    if (map == null)
      return new HashMap();
    synchronized (map) {
      return map instanceof TreeMap ? new TreeMap((TreeMap) map) : map instanceof LinkedHashMap ? new LinkedHashMap(map) : new HashMap(map);
    }
  }

  static public <A, B> List<B> cloneMap(Iterable<A> l, IF1<A, B> f) {
    List x = emptyList(l);
    if (l != null)
      for (A o : cloneList(l)) x.add(f.get(o));
    return x;
  }

  static public SimpleLiveValue<String> stringLiveValue() {
    return new SimpleLiveValue(String.class);
  }

  static public SimpleLiveValue<String> stringLiveValue(String value) {
    return new SimpleLiveValue(String.class, value);
  }

  static public void setSectionTitle(JComponent c, String title) {
    swing(() -> {
      var _c_1 = c;
      while (_c_1 != null) {
        var b = _c_1.getBorder();
        if (b != null) {
          if (b instanceof javax.swing.border.TitledBorder) {
            ((javax.swing.border.TitledBorder) b).setTitle(title);
            revalidate(_c_1);
            return;
          }
        }
        if (_c_1.getParent() instanceof JComponent)
          _c_1 = (JComponent) _c_1.getParent();
        else
          break;
      }
    });
  }

  static public <A> A enableScaffolding(A o) {
    if (o instanceof IMeta)
      ((IMeta) o).metaPut("scaffolding", true);
    return o;
  }

  static public int getCaretPosition(final JTextComponent c) {
    return c == null ? 0 : swing(new F0<Integer>() {

      public Integer get() {
        try {
          return c.getCaretPosition();
        } catch (Exception __e) {
          throw rethrow(__e);
        }
      }

      public String toString() {
        return "return c.getCaretPosition();";
      }
    });
  }

  static public SingleThread awtCalcEvery(JFrame f, int delay, int firstDelay, final Object runnable) {
    return awtCalcRegularly(f, delay, firstDelay, runnable);
  }

  static public SingleThread awtCalcEvery(JComponent c, int delay, int firstDelay, final Object runnable) {
    return awtCalcRegularly(c, delay, firstDelay, runnable);
  }

  static public SingleThread awtCalcEvery(JFrame f, int delay, final Object runnable) {
    return awtCalcRegularly(f, delay, delay, runnable);
  }

  static public SingleThread awtCalcEvery(JComponent c, int delay, Runnable runnable) {
    return awtCalcRegularly(c, delay, delay, runnable);
  }

  static public SingleThread awtCalcEvery(JComponent c, int delay, final Object runnable) {
    return awtCalcRegularly(c, delay, delay, runnable);
  }

  static public SingleThread awtCalcEvery(JComponent c, double delay, Runnable runnable) {
    return awtCalcEvery(c, delay, (Object) runnable);
  }

  static public SingleThread awtCalcEvery(JComponent c, double delay, Object runnable) {
    return awtCalcEvery(c, toMS_int(delay), runnable);
  }

  static public SingleThread awtCalcEvery(JComponent c, double firstDelay, double delay, final Object runnable) {
    return awtCalcEvery(c, toMS_int(delay), toMS_int(firstDelay), runnable);
  }

  static public JScrollPane jBorderlessHigherScrollPane(JComponent c) {
    return borderlessScrollPane(jHigherScrollPane(c));
  }

  static public JTextArea showTextWordWrapped(final String title, final String text) {
    return showWrappedText(title, text);
  }

  static public JTextArea showTextWordWrapped(Object text) {
    return showWrappedText(text);
  }

  static public void runInQAndWait(Q q, Runnable r) {
    if (r == null)
      return;
    if (isInQ(q)) {
      callF(r);
      return;
    }
    final Flag done = new Flag();
    final Var<Throwable> error = new Var();
    q.add(new Runnable() {

      public void run() {
        try {
          try {
            callF(r);
          } catch (Throwable e) {
            error.set(e);
          } finally {
            done.raise();
          }
        } catch (Exception __e) {
          throw rethrow(__e);
        }
      }

      public String toString() {
        return "try {\r\n      callF(r);\r\n    } catch (Throwable e) {\r\n      error.set(e);\r\n   ...";
      }
    });
    done.waitUntilUp();
    if (error.has())
      throw rethrow(error.get());
  }

  static public String exceptionToStringShorter_dontDropOuterExceptions(Throwable e) {
    String msg = hideCredentials(unnull(e.getMessage()));
    String className = baseClassName(e);
    if (!eq(className, "RuntimeException") && (msg.indexOf("Error") < 0 && msg.indexOf("Exception") < 0))
      return className + prependIfNempty(": ", msg);
    else
      return msg;
  }

  static public String exceptionToStringShorter(Throwable e) {
    e = getInnerException(e);
    return exceptionToStringShorter_dontDropOuterExceptions(e);
  }

  static public <A> A evalWithTimeoutOrTypedException(int timeoutMS, IF0<A> f) {
    return evalWithTimeoutOrTypedException(toSeconds(timeoutMS), f);
  }

  static public <A> A evalWithTimeoutOrTypedException(double timeoutSeconds, IF0<A> f) {
    Either<A, Thread> e = evalWithTimeout(timeoutSeconds, f);
    if (e.isA())
      return (A) e.a();
    throw new TimeoutException(timeoutSeconds, f, e.b());
  }

  static public <A> String pnlToString(String prefix, Iterable<A> l) {
    return hijackPrint(new Runnable() {

      public void run() {
        try {
          pnl(prefix, l);
        } catch (Exception __e) {
          throw rethrow(__e);
        }
      }

      public String toString() {
        return "pnl(prefix, l)";
      }
    });
  }

  static public <A> String pnlToString(final Iterable<A> l) {
    return hijackPrint(new Runnable() {

      public void run() {
        try {
          pnl(l);
        } catch (Exception __e) {
          throw rethrow(__e);
        }
      }

      public String toString() {
        return "pnl(l)";
      }
    });
  }

  static public <A> String pnlToString(final A[] l) {
    return hijackPrint(new Runnable() {

      public void run() {
        try {
          pnl(l);
        } catch (Exception __e) {
          throw rethrow(__e);
        }
      }

      public String toString() {
        return "pnl(l)";
      }
    });
  }

  static public <A, B> String pnlToString(final Map<A, B> map) {
    return hijackPrint(new Runnable() {

      public void run() {
        try {
          pnl(map);
        } catch (Exception __e) {
          throw rethrow(__e);
        }
      }

      public String toString() {
        return "pnl(map)";
      }
    });
  }

  static public <A, B> String pnlToString(MultiMap<A, B> map) {
    return pnlToString(multiMapToMap(map));
  }

  static public <B> TreeMap<String, B> toCIMap(Map<String, B> map) {
    return asCIMap(map);
  }

  static public BWImage scaleAndPosterize(IBWIntegralImage ii, SnPSettings settings) {
    return posterizeBWImage_withMeta(settings.colors, scaledBWImageFromBWIntegralImage_withMeta_height(settings.pixelRows, ii));
  }

  static public <A> A optCast(Class<A> c, Object o) {
    return isInstance(c, o) ? (A) o : null;
  }

  static public Pt translatePt(Pt a, Pt b) {
    return addPts(a, b);
  }

  static public Pt translatePt(int x, int y, Pt a) {
    return addPts(a, pt(x, y));
  }

  static public Pt translatePt(Pt a, int x, int y) {
    return translatePt(x, y, a);
  }

  static public Pt scalePt(Pt p, double f) {
    return new Pt(iround(p.x * f), iround(p.y * f));
  }

  static public Pt scalePt(double f, Pt p) {
    return scalePt(p, f);
  }

  static public Pt scalePt(int w, int h, double f) {
    return scalePt(new Pt(w, h), f);
  }

  static public Map<JButton, TextImageAction> makeNiceButtons_map = weakIdentityHashMap();

  static public <A extends DynamicStack> A makeNiceButtons_usingStack(A stack, Object... params) {
    params = flattenArray2(params);
    for (int i = 0; i < l(params); ) {
      TextImageAction tia = null;
      if (params[i] instanceof TextImageAction) {
        tia = (TextImageAction) params[i];
        i++;
      } else {
        tia = new TextImageAction(str(get(params, i)), str(get(params, i + 1)), get(params, i + 2));
        i += 3;
      }
      final TextImageAction _tia = tia;
      Object action = tia.action;
      final String buttonDesc = action == null ? "actionless button " + sfu(_tia) : "button " + sfu(cloneWithoutField(_tia, "action")) + " with action " + trim(simpleSpaces(newLinesToSpaces(shorten(str(tia.action), 40))));
      action = new Runnable() {

        public void run() {
          try {
            appendToLocalMechLog("User actions", "User clicked on " + buttonDesc);
            callF(_tia.action);
          } catch (Exception __e) {
            throw rethrow(__e);
          }
        }

        public String toString() {
          return "appendToLocalMechLog(\"User actions\", \"User clicked on \" + buttonDesc);\r\n     ...";
        }
      };
      JButton b = jImageAndTextButton(tia.imageID, tia.text, action);
      if (nempty(tia.toolTip))
        setToolTip(b, tia.toolTip);
      componentPopupMenu(b, tia.popupMenuMaker);
      resizeImageButtonToMax(b, niceButtons_maxImageSize());
      setVerticalTextPosition(JButton.TOP, setFontSize(15, makeBold(b)));
      setVerticalAlignment(JButton.TOP, b);
      setMargin(10, b);
      onMouseEnter(b, new Runnable() {

        public void run() {
          try {
            appendToLocalMechLog("Mouse hovers", "Mouse hovered over " + buttonDesc);
          } catch (Exception __e) {
            throw rethrow(__e);
          }
        }

        public String toString() {
          return "appendToLocalMechLog(\"Mouse hovers\", \"Mouse hovered over \" + buttonDesc)";
        }
      });
      onMouseExit(b, new Runnable() {

        public void run() {
          try {
            appendToLocalMechLog("Mouse hovers", "Mouse no longer hovers over " + buttonDesc);
          } catch (Exception __e) {
            throw rethrow(__e);
          }
        }

        public String toString() {
          return "appendToLocalMechLog(\"Mouse hovers\", \"Mouse no longer hovers over \" + buttonD...";
        }
      });
      makeNiceButtons_map.put(b, tia);
      stack.addComponent(b);
    }
    return stack;
  }

  static public DynamicHStack makeNiceButtons(Object... params) {
    return makeNiceButtons_usingStack((DynamicHStack) dynamicHStack().spacing(20), params);
  }

  static public Map<TextImageAction, File> filesForNiceButtons_map = weakIdentityHashMap();

  static public List<TextImageAction> filesForNiceButtons(List<File> l, IVF1<File> action) {
    return mapAndRecordToMap_reversed(filesForNiceButtons_map, l, new F1<File, TextImageAction>() {

      public TextImageAction get(final File f) {
        try {
          return textImageActionToolTip(f.getName(), isImageFile(f) ? "#1101250" : "#1101231", new Runnable() {

            public void run() {
              try {
                pcallF(action, f);
              } catch (Exception __e) {
                throw rethrow(__e);
              }
            }

            public String toString() {
              return "pcallF(action, f)";
            }
          }, f2s(f) + " (" + toK(fileSize(f)) + " K)");
        } catch (Exception __e) {
          throw rethrow(__e);
        }
      }

      public String toString() {
        return "textImageActionToolTip(\r\n      f.getName(),\r\n      isImageFile(f) ? #1101250 ...";
      }
    });
  }

  static public List<TextImageAction> filesForNiceButtons(List<File> l) {
    return filesForNiceButtons(l, f -> {
      {
        startThread(new Runnable() {

          public void run() {
            try {
              genericUI_openFile(f);
            } catch (Exception __e) {
              throw rethrow(__e);
            }
          }

          public String toString() {
            return "genericUI_openFile(f);";
          }
        });
      }
    });
  }

  static public boolean replaceNiceButtons(DynamicStack stack, Object... params) {
    boolean first = stack.isEmpty();
    stack.setComponents(makeNiceButtons(params).components());
    return first;
  }

  static public String showImage_defaultIcon = "#1004230";

  static public ImageSurface showImage(String snippetIDOrURL, String title) {
    return showImage(loadImage(snippetIDOrURL), title);
  }

  static public ImageSurface showImage(String title, BufferedImage img) {
    return showImage(img, title);
  }

  static public ImageSurface showImage(final BufferedImage img, final String title) {
    return (ImageSurface) swing(new F0<Object>() {

      public Object get() {
        try {
          ImageSurface is = showImage(img);
          getFrame(is).setTitle(title);
          return is;
        } catch (Exception __e) {
          throw rethrow(__e);
        }
      }

      public String toString() {
        return "ImageSurface is = showImage(img);\r\n    getFrame(is).setTitle(title);\r\n    ret...";
      }
    });
  }

  static public ImageSurface showImage(final BufferedImage img) {
    return (ImageSurface) swing(new F0<Object>() {

      public Object get() {
        try {
          ImageSurface is = new ImageSurface(img);
          JFrame frame = showPackedFrame(new JScrollPane(is));
          moveToTopRightCorner(frame);
          frameIcon(frame, showImage_defaultIcon);
          return is;
        } catch (Exception __e) {
          throw rethrow(__e);
        }
      }

      public String toString() {
        return "ImageSurface is = new ImageSurface(img);\r\n    JFrame frame = showPackedFrame(...";
      }
    });
  }

  static public ImageSurface showImage(String imageID) {
    return showImage(loadImage2(imageID));
  }

  static public ImageSurface showImage(ImageSurface surface, BufferedImage img) {
    return showImage(img, surface);
  }

  static public ImageSurface showImage(ImageSurface surface, String title, BufferedImage img) {
    return showImage(surface, img, title);
  }

  static public ImageSurface showImage(ImageSurface surface, BufferedImage img, String title) {
    return setFrameTitle(showImage(img, surface), title);
  }

  static public ImageSurface showImage(BufferedImage img, ImageSurface surface) {
    if (surface == null)
      return showImage(img);
    else {
      surface.setImage(img);
      return surface;
    }
  }

  static public ImageSurface showImage(String title, MakesBufferedImage img) {
    return showImage(title, img.getBufferedImage());
  }

  static public ImageSurface showImage(ImageSurface is, MakesBufferedImage img) {
    return showImage(is, img.getBufferedImage());
  }

  static public ImageSurface showImage(RGBImage img) {
    return showImage(img.getBufferedImage());
  }

  static public ImageSurface showImage(RGBImage img, String title) {
    ImageSurface is = showImage(img.getBufferedImage());
    getFrame(is).setTitle(title);
    return is;
  }

  static public ImageSurface showImage(ImageSurface surface, RGBImage img) {
    return showImage(img, surface);
  }

  static public ImageSurface showImage(RGBImage img, ImageSurface surface) {
    if (surface == null)
      return showImage(img);
    else {
      surface.setImage(img);
      return surface;
    }
  }

  static public ImageSurface showImage(ImageSurface surface, String title, RGBImage img) {
    return showImage(surface, img, title);
  }

  static public ImageSurface showImage(ImageSurface surface, RGBImage img, String title) {
    return setFrameTitle(showImage(img, surface), title);
  }

  static public ImageSurface showImage(MakesBufferedImage img) {
    return showImage(img.getBufferedImage());
  }

  static public ImageSurface showImage() {
    return showImage(currentImage());
  }

  static public ImageSurface showImage(File f) {
    return showImage(f2s(f), loadImage2(f)).setFile(f);
  }

  static public <A> IVF1<A> runnableToIVF1(Runnable r) {
    return r == null ? null : a -> r.run();
  }

  static public JPanel centerAndEastWithMargins(Component c, Component e) {
    return applyDefaultMargin(centerAndEast(c, withLeftMargin(e)));
  }

  static public int vstackWithSpacing_fixed_default = 10;

  static public JPanel vstackWithSpacing_fixed(List parts) {
    return vstackWithSpacing_fixed(parts, vstackWithSpacing_fixed_default);
  }

  static public JPanel vstackWithSpacing_fixed(List parts, int spacing) {
    return swing(() -> {
      JPanel panel = new JPanel(new GridBagLayout());
      GridBagConstraints gbc = new GridBagConstraints();
      gbc.weightx = 1;
      gbc.fill = GridBagConstraints.HORIZONTAL;
      gbc.gridwidth = GridBagConstraints.REMAINDER;
      gbc.insets = new Insets(0, 0, spacing, 0);
      smartAddWithLayout(panel, gbc, flattenToArray(parts));
      gbc.weighty = 1;
      gbc.insets = new Insets(0, 0, 0, 0);
      panel.add(jrigid(), gbc);
      return panel;
    });
  }

  static public JPanel vstackWithSpacing_fixed(Component... parts) {
    return vstackWithSpacing_fixed(vstackWithSpacing_fixed_default, parts);
  }

  static public JPanel vstackWithSpacing_fixed(int spacing, Component... parts) {
    return vstackWithSpacing_fixed(asList(parts), spacing);
  }

  static public JButton tableDependentButton(JTable tbl, String text) {
    return tableDependentButton(tbl, text, null);
  }

  static public JButton tableDependentButton(JTable tbl, String text, Runnable action) {
    return tableDependButton(tbl, jbutton(text, action));
  }

  static public JTextField jtextfield() {
    return jTextField();
  }

  static public JTextField jtextfield(String text) {
    return jTextField(text);
  }

  static public JTextField jtextfield(Object o) {
    return jTextField(o);
  }

  static public void createEmptyConceptsFileInDir(File dir) {
    File f = newFile(dir, conceptsFileName());
    if (!fileExists(f))
      saveGZStructureToFile(f, litmap());
  }

  static public JButton disableButton(final JButton b) {
    if (b != null) {
      swing(() -> {
        b.setEnabled(false);
      });
    }
    return b;
  }

  static public void disableButton() {
    disableButton(heldInstance(JButton.class));
  }

  static public boolean isValidFileName(String s) {
    return nempty(s) && !eqOneOf(s, ".", "..") && all(characters(s), c -> isValidFileCharacter(c));
  }

  static public boolean dirExists(String path) {
    return path != null && new File(path).isDirectory();
  }

  static public boolean dirExists(File f) {
    return f != null && f.isDirectory();
  }

  static public List<File> listDirsContainingFileNamed(File dir, String fileName) {
    return filter(listDirs(dir), d -> isFile(newFile(d, fileName)));
  }

  static public RuntimeException rethrowAndAppendToMessage(Throwable t, String msg) {
    String haveMsg = t.getMessage();
    if (empty(msg) || endsWith(haveMsg, " " + msg))
      throw rethrow(t);
    throw new RuntimeException(joinWithSpace(t.getMessage(), msg), t);
  }

  static public long incAtomicLong(AtomicLong l) {
    return l.incrementAndGet();
  }

  static public <A> String pnlToLines(String prefix, Iterable<A> l) {
    return pnlToString(prefix, l);
  }

  static public <A> String pnlToLines(Iterable<A> l) {
    return pnlToString(l);
  }

  static public <A> String pnlToLines(A[] l) {
    return pnlToString(l);
  }

  static public <A, B> String pnlToLines(Map<A, B> map) {
    return pnlToString(map);
  }

  static public <A, B> String pnlToLines(MultiMap<A, B> map) {
    return pnlToString(map);
  }

  static public Object callConstructor(String className, Object... args) {
    return nuObject(className, args);
  }

  static public <A> A callConstructor(Class<A> c, Object... args) {
    return nuObject(c, args);
  }

  static public Object[] mapToArray(Map map) {
    return mapToObjectArray(map);
  }

  static public Object[] mapToArray(Object f, Collection l) {
    return mapToObjectArray(f, l);
  }

  static public Object[] mapToArray(Object f, Object[] l) {
    return mapToObjectArray(f, l);
  }

  static public <A> Object[] mapToArray(Collection<A> l, IF1<A, Object> f) {
    return mapToObjectArray(l, f);
  }

  static public <A> Object[] mapToArray(A[] l, IF1<A, Object> f) {
    return mapToObjectArray(f, l);
  }

  static public <A> Object[] mapToArray(IF1<A, Object> f, A[] l) {
    return mapToObjectArray(f, l);
  }

  static public String strOrClassName(Object o) {
    if (o instanceof Class)
      return className((Class) o);
    return str(o);
  }

  static public boolean canCallWithVarargs(Object o, String method, Object... args) {
    if (o == null)
      return false;
    if (o instanceof Class) {
      Class c = (Class) o;
      _MethodCache cache = callOpt_getCache(c);
      if (cache.findStaticMethod(method, args) != null)
        return true;
      List<Method> methods = cache.cache.get(method);
      if (methods != null)
        methodSearch: for (Method m : methods) {
          {
            if (!(m.isVarArgs() && isStaticMethod(m)))
              continue;
          }
          if (massageArgsForVarArgsCall(m, args) != null)
            return true;
        }
    } else {
      Class c = o.getClass();
      _MethodCache cache = callOpt_getCache(c);
      if (cache.findMethod(method, args) != null)
        return true;
      List<Method> methods = cache.cache.get(method);
      if (methods != null)
        methodSearch: for (Method m : methods) {
          {
            if (!(m.isVarArgs()))
              continue;
          }
          if (massageArgsForVarArgsCall(m, args) != null)
            return true;
        }
    }
    return false;
  }

  static public <A> A _get(List<A> l, int idx) {
    return l != null && idx >= 0 && idx < l(l) ? l.get(idx) : null;
  }

  static public Object _get(Object o, String field) {
    return get(o, field);
  }

  static public Object _get(String field, Object o) {
    return get(o, field);
  }

  static public <A> A _get(A[] l, int idx) {
    return idx >= 0 && idx < l(l) ? l[idx] : null;
  }

  static public Method findMethod_precise_onTypes(Object o, String method, Class... argTypes) {
    try {
      if (o instanceof Class) {
        _MethodCache cache = callOpt_getCache((Class) o);
        List<Method> methods = cache.cache.get(method);
        Lowest<Method> best = new Lowest();
        if (methods != null)
          for (Method m : methods) {
            {
              if (!(isStaticMethod(m)))
                continue;
            }
            int score = methodApplicabilityScore_onTypes(m, argTypes);
            if (score < Integer.MAX_VALUE)
              best.put(m, score);
          }
        return best.get();
      }
      if (o == null)
        return null;
      _MethodCache cache = callOpt_getCache(o.getClass());
      List<Method> methods = cache.cache.get(method);
      Lowest<Method> best = new Lowest();
      if (methods != null)
        for (Method m : methods) {
          int score = methodApplicabilityScore_onTypes(m, argTypes);
          if (score < Integer.MAX_VALUE)
            best.put(m, score);
        }
      return best.get();
    } catch (Exception __e) {
      throw rethrow(__e);
    }
  }

  static public void assertSameSize(BufferedImage a, BufferedImage b) {
    assertEquals(a.getWidth(), b.getWidth());
    assertEquals(a.getHeight(), b.getHeight());
  }

  static public void assertSameSize(WidthAndHeight a, WidthAndHeight b) {
    assertEquals(a.getWidth(), b.getWidth());
    assertEquals(a.getHeight(), b.getHeight());
  }

  static public int iceil(double d) {
    return (int) Math.ceil(d);
  }

  static public int absDiff(int a, int b) {
    return abs(a - b);
  }

  static public Color colorWithAlpha(Color c, double alpha) {
    return new Color(c.getRed() / 255f, c.getGreen() / 255f, c.getBlue() / 255f, (float) clampZeroToOne(alpha));
  }

  static public Color colorWithAlpha(double alpha, Color c) {
    return colorWithAlpha(c, alpha);
  }

  static public void setComponent(SingleComponentPanel scp, Component c) {
    setSCPComponent(scp, c);
  }

  static public void setComponent(SingleComponentPanel scp, IF0<Component> c) {
    if (scp != null)
      setComponent(scp, callF(c));
  }

  static public boolean usingJTattoo() {
    return startsWith(className(currentLAF()), "com.jtattoo.");
  }

  static public void disposeWindowOnClick(final Window window) {
    AWTEventListener l = new AWTEventListener() {

      public void eventDispatched(AWTEvent evt) {
        if (!window.isVisible()) {
          Toolkit.getDefaultToolkit().removeAWTEventListener(this);
          return;
        }
        if (!(evt instanceof MouseEvent))
          return;
        Object source = evt.getSource();
        if (source == window && evt.getID() == MouseEvent.MOUSE_PRESSED) {
          Toolkit.getDefaultToolkit().removeAWTEventListener(this);
          window.dispose();
        }
      }
    };
    Toolkit.getDefaultToolkit().addAWTEventListener(l, AWTEvent.MOUSE_EVENT_MASK);
  }

  static public void addMouseListener(Container c, MouseListener l) {
    if (c != null && l != null) {
      swing(() -> {
        c.addMouseListener(l);
      });
    }
  }

  static public void addMouseListener(JComponent c, MouseListener l) {
    addMouseListener((Container) c, l);
  }

  static public Container getContentPane(Object o) {
    JFrame f = getFrame(o);
    return f == null ? null : f.getContentPane();
  }

  static public <A> void replaceLast(List<A> l, A a) {
    replaceLastElement(l, a);
  }

  static public <A> A[] toTypedArray(Class<A> type, Iterable<A> c) {
    return toArray(c, type);
  }

  static public String formatRecordVars(String recordName, Object... params) {
    return renderRecordVars(recordName, params);
  }

  static public boolean is(String a, String b) {
    return false;
  }

  static public boolean startsWithDigit(String s) {
    return nempty(s) && isDigit(s.charAt(0));
  }

  static public boolean isInteger(String s) {
    int n = l(s);
    if (n == 0)
      return false;
    int i = 0;
    if (s.charAt(0) == '-')
      if (++i >= n)
        return false;
    while (i < n) {
      char c = s.charAt(i);
      if (c < '0' || c > '9')
        return false;
      ++i;
    }
    return true;
  }

  static public boolean hasMethodNamed(Object obj, String method) {
    if (obj == null)
      return false;
    if (obj instanceof Class)
      return hasMethodNamed((Class) obj, method);
    return hasMethodNamed(obj.getClass(), method);
  }

  static public boolean hasMethodNamed(Class c, String method) {
    while (c != null) {
      for (Method m : c.getDeclaredMethods()) if (m.getName().equals(method))
        return true;
      c = c.getSuperclass();
    }
    return false;
  }

  static public <A, B> Collection<B> values(Map<A, B> map) {
    return map == null ? emptyList() : map.values();
  }

  static public Collection values(Object map) {
    return values((Map) map);
  }

  static public <A, B> Collection<B> values(MultiMap<A, B> mm) {
    return mm == null ? emptyList() : concatLists(values(mm.data));
  }

  static public <A, B> AutoCloseable tempMapPutAll(Map<A, B> map, Map<A, B> toAdd) {
    if (map != null && nempty(toAdd)) {
      List<Pair<A, B>> toRestore = new ArrayList();
      for (var __0 : _entrySet(toAdd)) {
        var key = __0.getKey();
        var value = __0.getValue();
        if (key != null && value != null) {
          B old = map.put(key, value);
          toRestore.add(pair(key, value));
        }
      }
      return () -> {
        for (var p : toRestore) mapPutOrRemove(map, p.a, p.b);
      };
    }
    return null;
  }

  static public <A, B> Map<A, B> mapWithSingleValue(Collection<A> l, B b) {
    HashMap<A, B> map = new HashMap();
    for (A a : unnull(l)) map.put(a, b);
    return map;
  }

  static public <A, B> AutoCloseable tempMapPut(Map<A, B> map, A key, B value) {
    if (map != null && key != null && value != null) {
      B old = map.put(key, value);
      return () -> mapPutOrRemove(map, key, old);
    }
    return null;
  }

  static public TreeSet mapToTreeSet(Object f, Iterable l) {
    TreeSet x = new TreeSet();
    if (l != null)
      for (Object o : l) x.add(callF(f, o));
    return x;
  }

  static public <A, B> TreeSet<B> mapToTreeSet(IF1<A, B> f, Iterable<A> l) {
    TreeSet<B> x = new TreeSet();
    if (l != null)
      for (var o : l) x.add(f.get(o));
    return x;
  }

  static public <A, B> TreeSet<B> mapToTreeSet(Iterable<A> l, IF1<A, B> f) {
    return mapToTreeSet(f, l);
  }

  static public boolean isAnonymousClassName(String s) {
    for (int i = 0; i < l(s); i++) if (s.charAt(i) == '$' && Character.isDigit(s.charAt(i + 1)))
      return true;
    return false;
  }

  static public String longestPrefixInTreeSet(String s, TreeSet<String> set) {
    return longestPrefixInNavigableSet(s, set);
  }

  static public <A> List<A> itemPlus(A a, Collection<A> l) {
    return itemPlusList(a, l);
  }

  static public List<String> standardImports_fullyImportedPackages() {
    return endingWith_dropSuffix(standardImports(), ".*");
  }

  static public String shortClassName(Object o) {
    if (o == null)
      return null;
    Class c = o instanceof Class ? (Class) o : o.getClass();
    String name = c.getName();
    return shortenClassName(name);
  }

  static public Map<Integer, Integer> rsyntaxTextArea_fixNumPad_map = litmap(KeyEvent.VK_UP, KeyEvent.VK_KP_UP, KeyEvent.VK_DOWN, KeyEvent.VK_KP_DOWN, KeyEvent.VK_LEFT, KeyEvent.VK_KP_LEFT, KeyEvent.VK_RIGHT, KeyEvent.VK_KP_RIGHT);

  static public boolean rsyntaxTextArea_fixNumPad_done = false;

  static public void rsyntaxTextArea_fixNumPad() {
    if (rsyntaxTextArea_fixNumPad_done)
      return;
    RSyntaxTextAreaDefaultInputMap inputMap = new RSyntaxTextAreaDefaultInputMap();
    for (KeyStroke key : inputMap.keys()) {
      Integer code = rsyntaxTextArea_fixNumPad_map.get(key.getKeyCode());
      if (code != null)
        inputMap.put(KeyStroke.getKeyStroke(code, key.getModifiers()), inputMap.get(key));
    }
    UIManager.put("RSyntaxTextAreaUI.inputMap", inputMap);
  }

  static public boolean javaxSyntaxTextArea_numPadFix = true;

  static public RSyntaxTextArea javaxSyntaxTextArea() {
    return swing(new F0<RSyntaxTextArea>() {

      public RSyntaxTextArea get() {
        try {
          RSyntaxTextArea textArea = new RSyntaxTextArea(1, 10);
          if (javaxSyntaxTextArea_numPadFix)
            new NumPadFixingInputMap().replaceOn(textArea);
          textArea.setSyntaxEditingStyle(SyntaxConstants.SYNTAX_STYLE_JAVA);
          textArea.setTabSize(2);
          textArea.setTabsEmulated(true);
          textArea.setCodeFoldingEnabled(false);
          textArea.setMarkOccurrences(true);
          return textArea;
        } catch (Exception __e) {
          throw rethrow(__e);
        }
      }

      public String toString() {
        return "RSyntaxTextArea textArea = new RSyntaxTextArea(1, 10);\r\n    if (javaxSyntaxTe...";
      }
    });
  }

  static public Font deriveFont(Font font, float size) {
    return font == null ? null : font.deriveFont(size);
  }

  static public File loadLibrary(String snippetID) {
    return loadBinarySnippet(snippetID);
  }

  static public File pathToJavaxJar() {
    IResourceLoader rl = vm_getResourceLoader();
    if (rl != null)
      return rl.pathToJavaXJar();
    return pathToJavaxJar_noResourceLoader();
  }

  static public File pathToJavaxJar_noResourceLoader() {
    try {
      int x = latestInstalledJavaX();
      File xfile = new File(userHome(), ".javax/x" + Math.max(x, 30) + ".jar");
      if (!xfile.isFile()) {
        print("Saving " + f2s(xfile));
        String url = x30JarServerURL();
        byte[] data = loadBinaryPage(url);
        if (data.length < 1000000)
          throw fail("Could not load " + url);
        saveBinaryFile(xfile.getPath(), data);
      }
      return xfile;
    } catch (Exception __e) {
      throw rethrow(__e);
    }
  }

  static public <A, B> void put(Map<A, B> map, A a, B b) {
    if (map != null)
      map.put(a, b);
  }

  static public <A> void put(List<A> l, int i, A a) {
    if (l != null && i >= 0 && i < l(l))
      l.set(i, a);
  }

  static public Method hashMap_findKey_method;

  static public <A, B> A hashMap_findKey(HashMap<A, B> map, Object key) {
    try {
      if (hashMap_findKey_method == null)
        hashMap_findKey_method = findMethodNamed(HashMap.class, "getNode");
      Map.Entry<A, B> entry = (Map.Entry) hashMap_findKey_method.invoke(map, hashMap_internalHash(key), key);
      return entry == null ? null : entry.getKey();
    } catch (Exception __e) {
      throw rethrow(__e);
    }
  }

  static public java.util.Timer doAfter(long delay, Object r) {
    return doLater(delay, r);
  }

  static public java.util.Timer doAfter(double delaySeconds, Object r) {
    return doLater(delaySeconds, r);
  }

  static public <A extends Window> void disposeWindows(final Collection<A> l) {
    for (Window w : unnull(l)) disposeWindow(w);
  }

  static public void stepMaxWithStats(Steppable s, long maxSteps) {
    stepAllWithStats(s, maxSteps);
  }

  static public void stepMaxWithStats(long maxSteps, Steppable s) {
    stepMaxWithStats(s, maxSteps);
  }

  static public <A> Set<A> syncSet() {
    return synchroHashSet();
  }

  static public <A> Set<A> syncSet(Collection<A> l) {
    return addAllAndReturnCollection(synchroHashSet(), l);
  }

  static public String nResults(int n) {
    return n2(n, "result");
  }

  static public String nResults(Collection l) {
    return nResults(l(l));
  }

  static public String formatSeconds(long ms, int digits) {
    return formatDouble(toS(ms), digits);
  }

  static public DynamicHStack dynamicHStack(Component... components) {
    DynamicHStack stack = swingNu(DynamicHStack.class);
    stack.addComponents(asList(components));
    return stack;
  }

  static public JComponent withCenteredBoldTitle(String title, Component c) {
    return withTitle(jCenteredBoldLabel(title), c);
  }

  static public JPanel northCenterAndSouthWithMargin(Component n, Component c, Component s) {
    return northCenterAndSouth(withBottomMargin(n), c, withTopMargin(s));
  }

  static public JPanel northCenterAndSouthWithMargin(int margin, Component n, Component c, Component s) {
    return northCenterAndSouth(withBottomMargin(margin, n), c, withTopMargin(margin, s));
  }

  static public JLabel centeredLiveValueLabel(LiveValue lv) {
    return jCenteredLiveValueLabel(lv);
  }

  static public JPanel jCenteredLine(Component... components) {
    return jcenteredline(components);
  }

  static public JPanel jCenteredLine(List<? extends Component> components) {
    return jcenteredline(components);
  }

  static public AutoCloseable tempSetRandomSeed(int seed) {
    return tempSetCustomRandomizerForThisThread(new Random(seed));
  }

  static public JComponent jSmallErrorView(Throwable e) {
    var btn = jimageButtonScaledToWidth(32, errorIconID(), "Show error details", () -> showErrorFrame(e));
    var label = jlabel_noAutoToolTip(exceptionType(e));
    return jline(btn, label);
  }

  static public void addAndRevalidate(Container c, Component x) {
    addAndValidate(c, x);
  }

  static public double calcFitScale(BufferedImage image, Component c) {
    return calcFitScale(image, c.getWidth(), c.getHeight());
  }

  static public double calcFitScale(BufferedImage image, int w) {
    return calcFitScale(image, w, w);
  }

  static public double calcFitScale(BufferedImage image, int w, int h) {
    int iw = image.getWidth(), ih = image.getHeight();
    return max(doubleRatio(h, ih), doubleRatio(w, iw));
  }

  static public BufferedImage scaleImageWithOp(BufferedImage before, double scaleX, int affineTransformOpType) {
    return scaleImageWithOp(before, scaleX, scaleX, affineTransformOpType);
  }

  static public BufferedImage scaleImageWithOp(BufferedImage before, double scaleX, double scaleY, int affineTransformOpType) {
    if (scaleX == 1 && scaleY == 1)
      return before;
    int w = before.getWidth();
    int h = before.getHeight();
    int neww = max(1, iround(w * scaleX)), newh = max(1, iround(h * scaleY));
    BufferedImage after = new BufferedImage(neww, newh, BufferedImage.TYPE_INT_ARGB);
    AffineTransform at = new AffineTransform();
    at.scale(scaleX, scaleY);
    AffineTransformOp scaleOp = new AffineTransformOp(at, affineTransformOpType);
    return scaleOp.filter(before, after);
  }

  static public BufferedImage addBorderToImage(BufferedImage img, Color color, int border) {
    return img_addBorder(img, color, border);
  }

  static public <A extends JComponent> A withToolTip(A c, final Object toolTip) {
    return setToolTipText(c, toolTip);
  }

  static public <A extends JComponent> A withToolTip(Object toolTip, A c) {
    return setToolTipText(toolTip, c);
  }

  static public <A extends JComponent> A setMargin(final int w, final int h, final A a) {
    if (a != null) {
      swing(() -> {
        a.setBorder(BorderFactory.createEmptyBorder(h, w, h, w));
      });
    }
    return a;
  }

  static public <A extends JComponent> A setMargin(int w, A a) {
    return setMargin(w, w, a);
  }

  static public <A extends JComponent> A jMaxWidth(int w, A c) {
    Dimension size = c.getMaximumSize();
    c.setMaximumSize(new Dimension(w, size.height));
    return jPreferWidth(w, c);
  }

  static public <A extends JComponent> A jMaxWidth(A c, int w) {
    return jMaxWidth(w, c);
  }

  static public JComponent withCenteredTitle(String title, Component c) {
    return withTitle(jCenteredLabel(title), c);
  }

  static public JLabel jImage_scaledToHeight(String imageID, int height) {
    return jImage_scaledToHeight(imageID, height, null);
  }

  static public JLabel jImage_scaledToHeight(String imageID, int height, String toolTip) {
    return setToolTip(toolTip, jImage(resizeImageToHeight_bilinear(loadImage2(imageID), height)));
  }

  static public JLabel jImage_scaledToHeight(int height, String imageID) {
    return jImage_scaledToHeight(height, imageID, null);
  }

  static public JLabel jImage_scaledToHeight(int height, String imageID, String toolTip) {
    return jImage_scaledToHeight(imageID, height, toolTip);
  }

  static public String checkmarkIconID() {
    return "#1103071";
  }

  static public String textOut_or(Collection l) {
    return textOut_or(l, "nothing");
  }

  static public String textOut_or(Collection l, String emptyText) {
    if (empty(l))
      return emptyText;
    List<String> separators = rep(", ", l(l) - 2);
    separators.add(" or ");
    return join_flex(separators, l);
  }

  static public String aOrAn(String s) {
    return a(s);
  }

  static public <A> Map<String, A> syncCIMap() {
    return (Map) synchroMap(caseInsensitiveMap());
  }

  static public JPanel comboBoxAndButton(JComboBox cb, String buttonText, IVF1<String> onEnter) {
    Runnable r = new Runnable() {

      public void run() {
        try {
          callF(onEnter, getText(cb));
        } catch (Exception __e) {
          throw rethrow(__e);
        }
      }

      public String toString() {
        return "callF(onEnter, getText(cb))";
      }
    };
    return centerAndEastWithMargin(onEnter(cb, r), jbutton(buttonText, r));
  }

  static public ThreadLocal<Boolean> bindComboBoxToLiveValue_debug = new ThreadLocal();

  static public <A extends JComboBox> A bindComboBoxToLiveValue(final A cb, final SimpleLiveValue<String> lv) {
    final boolean debug = isTrue(bindComboBoxToLiveValue_debug.get());
    bindLiveValueListenerToComponent(cb, lv, new Runnable() {

      public void run() {
        try {
          selectItem(cb, lv.get());
        } catch (Exception __e) {
          throw rethrow(__e);
        }
      }

      public String toString() {
        return "selectItem(cb, lv!)";
      }
    });
    onChange(cb, new Runnable() {

      public void run() {
        try {
          String s = getText(cb);
          if (debug)
            print("ComboBox: " + s);
          lv.set(s);
        } catch (Exception __e) {
          throw rethrow(__e);
        }
      }

      public String toString() {
        return "String s = getText(cb); // also works on editable combo boxes\r\n    if (debug)...";
      }
    });
    return cb;
  }

  static public AutoCloseable tempEnter(Object o) {
    return o == null ? null : optCast(AutoCloseable.class, rcallOpt("enter", o));
  }

  static public AutoCloseable tempEnter(Enterable o) {
    return o == null ? null : o.enter();
  }

  static public JComponent jErrorView(Throwable e) {
    return jSmallErrorView(e);
  }

  static public <A, B> List<A> cloneKeys(Map<A, B> map) {
    return cloneList(keys(map));
  }

  static public <A> List<A> listSetIntersection(Iterable<A> a, Collection<A> b) {
    List<A> l = new ArrayList();
    Set<A> bSet = asSet(b);
    for (A x : unnull(a)) if (bSet.contains(x))
      l.add(x);
    return l;
  }

  static public Class veryQuickJava_finish_specialMainClass(String mainClassName, String src) {
    return veryQuickJava_finish_specialMainClass(mainClassName, src, null);
  }

  static public Class veryQuickJava_finish_specialMainClass(String mainClassName, String src, List<String> libs) {
    src = findTranslators2(src, libs = cloneList(libs));
    File bytecode = javaCompile_overInternalBot(src, join(" ", libs));
    return hotwireCoreSpecialMainClass(mainClassName, concatLists(ll(bytecode), loadLibraries(libs)));
  }

  static public String stringify(IStringifier stringifier, Object o) {
    return stringifier == null ? str(o) : stringifier.toString(o);
  }

  static public String dropPrefixFromLines(String prefix, String s) {
    return mapEachLine(s, line -> dropPrefix(prefix, line));
  }

  static public class ECJError {

    public String file, error;

    public int lineNr;

    public String codeLine;

    public IntRange colRange;

    public String toString() {
      return "Error on line " + lineNr + ": " + error;
    }
  }

  static public List<ECJError> parseECJOutputForErrors(String text) {
    List<ECJError> errors = new ArrayList();
    List<String> lines = lines(text);
    for (int i = 0; i < l(lines); i++) {
      if (startsWith(lines.get(i), "---")) {
        String line = get(lines, i + 1);
        List<String> groups = regexpFirstGroups("^\\d+\\. ERROR in (.*?) \\(at line (\\d+)\\)$", line);
        if (groups != null) {
          String codeLine = get(lines, i + 2);
          String markLine = get(lines, i + 3);
          String errorLine = get(lines, i + 4);
          List<String> markGroups = regexpFirstGroups("^( *)(\\^+)", markLine);
          ECJError e = new ECJError();
          e.file = groups.get(0);
          e.error = errorLine;
          e.lineNr = parseInt(groups.get(1));
          e.codeLine = codeLine;
          int col1 = l(first(markGroups));
          int cols = l(second(markGroups));
          e.colRange = intRangeWithLength(col1 + 1, cols);
          errors.add(e);
        }
      }
    }
    return errors;
  }

  static public void pnlQuoted(Collection<String> l) {
    pnl(quoteAll(l));
  }

  static public IterableIterator<String> lines_iterator(final String s) {
    if (s == null)
      return emptyIterableIterator();
    return iteratorFromFunction(new F0<String>() {

      public int start = 0;

      public String get() {
        int i = toLines_nextLineBreak(s, start);
        if (i < 0) {
          String toReturn = s.length() > start ? s.substring(start) : null;
          start = s.length();
          return toReturn;
        }
        String toReturn = s.substring(start, i);
        if (s.charAt(i) == '\r' && i + 1 < s.length() && s.charAt(i + 1) == '\n')
          i += 2;
        else
          ++i;
        start = i;
        return toReturn;
      }
    });
  }

  static public int indexOfLine(String text, String sub) {
    return indexOf(lines_iterator(text), sub);
  }

  static public String tabsToSpaces(String s) {
    return tabsToSpaces(2, s);
  }

  static public String tabsToSpaces(int spacesPerTab, String s) {
    return replace(s, "\t", repSpace(spacesPerTab));
  }

  static public String tok_moveImportsUp(String src) {
    return join(tok_moveImportsUp(javaTok(src)));
  }

  static public List<String> tok_moveImportsUp(List<String> tok) {
    StringBuilder buf = new StringBuilder();
    int i;
    Set<String> have = new HashSet();
    for (i = 1; i < l(tok); i += 2) if (eq(tok.get(i), "import")) {
      int j = indexOf(tok, i + 2, ";");
      if (j < 0)
        break;
      String s = joinSubList(tok, i, j + 1);
      have.add(s);
      i = j;
    } else
      break;
    List<IntRange> reToks = new ArrayList();
    for (; i < l(tok); i += 2) if (eq(tok.get(i), "import")) {
      int j = indexOf(tok, i + 2, ";");
      if (j < 0)
        continue;
      String s = joinSubList(tok, i, j + 1);
      if (!have.contains(s)) {
        buf.append(s).append("\n");
        have.add(s);
      }
      replaceTokens(tok, i, j + 1, "");
      reToks.add(intRange(i, j + 1));
      i -= 2;
    }
    if (nempty(buf)) {
      if (l(tok) == 1)
        addAll(tok, "", "");
      tok.set(1, str(buf) + "\n" + tok.get(1));
      reToks.add(intRange(1, 2));
    }
    return reTok_multi(tok, reToks);
  }

  static public <A> void setComboBoxItems_notifyListeners(JComboBox<A> cb, Collection<A> items) {
    if (cb != null) {
      swing(() -> {
        if (eq(getComboBoxItems(cb), items))
          return;
        var sel = getSelectedItem_typed(cb);
        setComboBoxItems(cb, items);
        var item = getSelectedItem_typed(cb);
        if (!eq(sel, item)) {
          if (sel != null && contains(items, sel))
            setSelectedItem(cb, sel);
          else {
            setSelectedItem(cb, (A) null);
            setSelectedItem(cb, item);
          }
        }
      });
    }
  }

  static public <A extends Concept> List<A> sortConceptsByID(Collection<A> l) {
    return sortedByCalculatedField(l, c -> c.id);
  }

  static public long lround(double d) {
    return Math.round(d);
  }

  static public long lround(Number n) {
    return lround(toDouble(n));
  }

  static public void close(AutoCloseable c) {
    _close(c);
  }

  static public float clamp(float x, float a, float b) {
    return x < a ? a : x > b ? b : x;
  }

  static public double clamp(double x, double a, double b) {
    return x < a ? a : x > b ? b : x;
  }

  static public int clamp(int x, int a, int b) {
    return x < a ? a : x > b ? b : x;
  }

  static public long clamp(long x, long a, long b) {
    return x < a ? a : x > b ? b : x;
  }

  static public <A> List<A> addOrCreate(List<A> l, A a) {
    return addDyn(l, a);
  }

  static public <A> Set<A> addOrCreate(Set<A> l, A a) {
    return createOrAddToSet(l, a);
  }

  static public Runnable runAndReturn(Runnable r) {
    callF(r);
    return r;
  }

  static public <A, B> LinkedHashMap<A, B> cloneLinkedHashMap(Map<A, B> map) {
    return map == null ? new LinkedHashMap() : new LinkedHashMap(map);
  }

  static public JTextField jLiveTextField(SimpleLiveValue<String> lv) {
    return jLiveValueTextField_bothWays(lv);
  }

  static public boolean sameSize(WidthAndHeight a, BufferedImage b) {
    return a != null && b != null && a.getWidth() == b.getWidth() && a.getHeight() == b.getHeight();
  }

  static public float bwDistance(BWImage a, BWImage b, float maxDistance) {
    return 1f - bwImageSimilarityResized(a, b, 1f - maxDistance);
  }

  static public float bwDistance(BWImage a, BWImage b) {
    return bwDistance(a, b, 1f);
  }

  static public BWImage toBWImage(RGBImage img) {
    return toBW(img);
  }

  static public BWImage toBWImage(BufferedImage img) {
    return img == null ? null : new BWImage(img);
  }

  static public BWImage toBWImage(MakesBufferedImage img) {
    if (img == null)
      return null;
    if (img instanceof BWImage)
      return ((BWImage) img);
    return new BWImage(toBufferedImage(img));
  }

  static public String formatDoubleX(double d, int digits) {
    return formatDoubleFull(d, digits);
  }

  static public WatchEvent.Kind[] jdk_watchService_allEventKinds() {
    return new WatchEvent.Kind[] { ENTRY_CREATE, ENTRY_DELETE, ENTRY_MODIFY, OVERFLOW };
  }

  static public List<File> findAllDirs(File dir) {
    List<File> out = new ArrayList();
    findAllDirs(dir, out);
    return out;
  }

  static public void findAllDirs(File dir, List<File> out) {
    out.add(dir);
    try {
      for (File f : listFiles(dir)) if (f.isDirectory())
        findAllDirs(f, out);
    } catch (Throwable __e) {
      print(exceptionToStringShort(__e));
    }
  }

  static public <A> IterableIterator<A> reversedIterator(final List<A> l) {
    return new IterableIterator<A>() {

      public int i = l(l) - 1;

      public boolean hasNext() {
        return i >= 0;
      }

      public A next() {
        return l.get(i--);
      }
    };
  }

  static public LineAndColumn tokenToLineAndColumn(ListAndIndex<String> ptr) {
    return ptr == null ? null : tokenToLineAndColumn(ptr.list(), ptr.idx());
  }

  static public LineAndColumn tokenToLineAndColumn(List<String> tok, int tokenIndex) {
    int line = 1, col = 1;
    tokenIndex = min(tokenIndex, l(tok));
    for (int i = 0; i < tokenIndex; i++) {
      String t = tok.get(i);
      int n = l(t);
      for (int j = 0; j < n; j++) if (t.charAt(j) == '\n') {
        ++line;
        col = 1;
      } else
        ++col;
    }
    return new LineAndColumn(line, col);
  }

  static public <A, B> Map<A, B> putAll(Map<A, B> a, Map<? extends A, ? extends B> b) {
    if (a != null && b != null)
      a.putAll(b);
    return a;
  }

  static public <A, B> MultiMap<A, B> putAll(MultiMap<A, B> a, Map<? extends A, ? extends B> b) {
    if (a != null)
      a.putAll((Map) b);
    return a;
  }

  static public <A, B> Map<A, B> putAll(Map<A, B> a, Object... b) {
    if (a != null)
      litmap_impl(a, b);
    return a;
  }

  static public Set emptySet() {
    return new HashSet();
  }

  static public <A> A getAndClear(IVar<A> v) {
    A a = v.get();
    v.set(null);
    return a;
  }

  static public <A, B> Set<A> keySet(Map<A, B> map) {
    return map == null ? new HashSet() : map.keySet();
  }

  static public Set keySet(Object map) {
    return keys((Map) map);
  }

  static public <A> Set<A> keySet(MultiSet<A> ms) {
    return ms.keySet();
  }

  static public <A, B> Set<A> keySet(MultiMap<A, B> mm) {
    return mm.keySet();
  }

  static public <A> A reverseGet(List<A> l, int idx) {
    if (l == null || idx < 0)
      return null;
    int n = l(l);
    return idx < n ? l.get(n - 1 - idx) : null;
  }

  static public <A, B> Map.Entry<A, B> firstEntry(Map<A, B> map) {
    return empty(map) ? null : first(map.entrySet());
  }

  static public <A, B> A firstKey(Map<A, B> map) {
    return first(keys(map));
  }

  static public <A, B> A firstKey(MultiSetMap<A, B> map) {
    return map == null ? null : firstKey(map.data);
  }

  static public <A, B> A firstKey(MultiMap<A, B> map) {
    return map == null ? null : firstKey(map.data);
  }

  static public <A> Set<A> weakIdentityHashSet() {
    return new WeakIdentityHashSet();
  }

  static public JScrollPane enclosingScrollPane(Component c) {
    while (c.getParent() != null && !(c.getParent() instanceof JViewport) && c.getParent().getComponentCount() == 1) c = c.getParent();
    if (!(c.getParent() instanceof JViewport))
      return null;
    c = c.getParent().getParent();
    return c instanceof JScrollPane ? (JScrollPane) c : null;
  }

  static public ChangeListener scrollPaneOnScroll(final JScrollPane sp, final Object onScroll) {
    return swing(new F0<ChangeListener>() {

      public ChangeListener get() {
        try {
          ChangeListener l = changeListener(onScroll);
          sp.getViewport().addChangeListener(l);
          return l;
        } catch (Exception __e) {
          throw rethrow(__e);
        }
      }

      public String toString() {
        return "ChangeListener l = changeListener(onScroll);\r\n    sp.getViewport().addChangeL...";
      }
    });
  }

  static public <A> List<A> reversed(Iterable<A> l) {
    return reversedList(l);
  }

  static public <A> List<A> reversed(A[] l) {
    return reversedList(asList(l));
  }

  static public String reversed(String s) {
    return reversedString(s);
  }

  static public List<Component> stackElementsShowing(final DynamicStack stack) {
    return swing(new F0<List<Component>>() {

      public List<Component> get() {
        try {
          List<Component> l = new ArrayList();
          if (!stack.isShowing())
            return l;
          JScrollPane sp = enclosingScrollPane(stack);
          if (sp == null)
            return l;
          JViewport vp = sp.getViewport();
          Rect vpRect = toRect(vp.getBounds());
          for (Component c : stack.components()) if (rectsIntersect(vpRect, boundsInParent(c, vp)))
            l.add(c);
          return l;
        } catch (Exception __e) {
          throw rethrow(__e);
        }
      }

      public String toString() {
        return "new L<Component> l;\r\n    if (!stack.isShowing()) ret l;\r\n    JScrollPane sp =...";
      }
    });
  }

  static public <A> boolean add_byContains(Collection<A> c, A a) {
    if (c == null)
      return false;
    synchronized (collectionMutex(c)) {
      if (c.contains(a))
        return false;
      c.add(a);
      return true;
    }
  }

  static public DeQ startDeQ() {
    return new DeQ();
  }

  static public int loadPreviewImage_maxSize = 128;

  static public BufferedImage loadPreviewImage(File f) {
    return scaleBufferedImageToMax(loadBufferedImage(f), loadPreviewImage_maxSize);
  }

  static public BufferedImage loadPreviewImageWithExactHeight(int h, File f) {
    return scaleBufferedImageToHeight(h, loadBufferedImage(f));
  }

  static public File byteCodePathForClass(Class c) {
    if (c == null)
      return null;
    ClassLoader cl = getClassLoader(c);
    Collection<File> files = (Collection<File>) (getOpt(cl, "files"));
    if (files != null) {
      String name = c.getName().replace('.', '/') + ".class";
      for (File location : files) if (dirOrZipContainsPath(location, name))
        return location;
      throw fail(name + " not found in: " + files);
    }
    return null;
  }

  static public File byteCodePathForClass(Object o) {
    return byteCodePathForClass(_getClass(o));
  }

  static public Class<?> getClass(String name) {
    return _getClass(name);
  }

  static public Class getClass(Object o) {
    return _getClass(o);
  }

  static public Class getClass(Object realm, String name) {
    return _getClass(realm, name);
  }

  static public <A> List<A> itemPlusList(A a, Collection<A> l) {
    return concatLists(ll(a), l);
  }

  static public List<String> endingWith_dropSuffix(Collection<String> l, String suffix) {
    List<String> out = new ArrayList();
    for (String s : unnullForIteration(l)) if (endsWith(s, suffix))
      out.add(dropLast(l(suffix), s));
    return out;
  }

  static public List<String> endingWith_dropSuffix(String suffix, Collection<String> l) {
    return endingWith_dropSuffix(l, suffix);
  }

  static public List<String> standardImports_cache;

  static public List<String> standardImports() {
    if (standardImports_cache == null)
      standardImports_cache = standardImports_load();
    return standardImports_cache;
  }

  static public List<String> standardImports_load() {
    return ll("java.util.*", "java.util.zip.*", "java.util.List", "java.util.regex.*", "java.util.concurrent.*", "java.util.concurrent.atomic.*", "java.util.concurrent.locks.*", "java.util.function.*", "javax.swing.*", "javax.swing.event.*", "javax.swing.text.*", "javax.swing.table.*", "java.io.*", "java.net.*", "java.lang.reflect.*", "java.lang.ref.*", "java.lang.management.*", "java.security.*", "java.security.spec.*", "java.awt.*", "java.awt.event.*", "java.awt.image.*", "java.awt.geom.*", "javax.imageio.*", "java.math.*");
  }

  static public List<String> classNamesInLoadedJigsawModules() {
    return concatMap(loadedJigsawModuleNames(), moduleName -> classNamesInJigsawModule(moduleName));
  }

  static public <A> List<A> listPlus(Collection<A> l, A... more) {
    return concatLists(l, asList(more));
  }

  static public ISleeper defaultSleeper() {
    return new ISleeper() {

      public java.util.Timer timer;

      public void doLater(long targetSysTime, Runnable r) {
        timer = loadableUtils.utils.doLater(max(0, targetSysTime - sysNow()), r);
      }

      public void close() {
        cancelTimer(timer);
      }
    };
  }

  static public void runWithExecutor(Runnable r, Executor e) {
    if (e == null)
      r.run();
    else
      e.execute(r);
  }

  static public void drawLine(BufferedImage image, int x1, int y1, int x2, int y2, Color color) {
    drawLine(imageGraphics(image), x1, y1, x2, y2, color);
  }

  static public void drawLine(Graphics2D g, int x1, int y1, int x2, int y2, Color color) {
    g.setColor(color);
    g.drawLine(x1, y1, x2, y2);
  }

  static public void drawLine(BufferedImage image, Pt a, Pt b, Color color) {
    drawLine(imageGraphics(image), a, b, color);
  }

  static public void drawLine(Graphics2D g, Pt a, Pt b, Color color) {
    drawLine(g, a.x, a.y, b.x, b.y, color);
  }

  static public boolean oneIn(int n) {
    return random(n) == 0;
  }

  static public boolean oneIn(int n, Random random) {
    return random(random, n) == 0;
  }

  static public boolean oneIn(Random random, int n) {
    return oneIn(n, random);
  }

  static public Map syncHashMap() {
    return synchroHashMap();
  }

  static public void register(Concept c) {
    registerConcept(c);
  }

  static public <A, B> List<B> getAll(Map<A, B> map, Collection<A> l) {
    return lookupAllOpt(map, l);
  }

  static public <A, B> List<B> getAll(Collection<A> l, Map<A, B> map) {
    return lookupAllOpt(map, l);
  }

  static public <A, B extends IF0<A>> List<A> getAll(Iterable<B> l) {
    return getVars(l);
  }

  static public <A, B> List<A> cloneKeys_noSync(Map<A, B> map) {
    return cloneList_noSync(keys(map));
  }

  static public <A, B> IterableIterator<B> navigableMultiSetMapValuesIterator_concurrent(final MultiSetMap<A, B> mm) {
    return navigableMultiSetMapValuesIterator_concurrent(mm, mm.data);
  }

  static public <A, B> IterableIterator<B> navigableMultiSetMapValuesIterator_concurrent(final MultiSetMap<A, B> mm, Object mutex) {
    return iteratorFromFunction(new F0<B>() {

      public Iterator<Set<B>> it = concurrentlyIterateValues((NavigableMap) mm.data, mutex);

      public Iterator<B> it2;

      public B get() {
        while (it2 == null || !it2.hasNext()) {
          if (!it.hasNext())
            return null;
          it2 = iterator(asList(it.next()));
        }
        return it2.next();
      }
    });
  }

  static public <A, B> MultiSet<A> multiSetMapToMultiSet(MultiSetMap<A, B> mm) {
    MultiSet<A> ms = new MultiSet();
    for (A a : keys(mm)) ms.add(a, l(mm.get(a)));
    return ms;
  }

  static public Collection<Concept> allConcepts() {
    return db_mainConcepts().allConcepts();
  }

  static public Collection<Concept> allConcepts(Concepts concepts) {
    return concepts.allConcepts();
  }

  static public boolean containsInstance(Iterable i, Class c) {
    if (i != null)
      for (Object o : i) if (isInstanceX(c, o))
        return true;
    return false;
  }

  static public <B> Map<String, B> humanizeKeys(Map<String, B> map) {
    return mapKeys(__71 -> humanizeFormLabel(__71), map);
  }

  static public Map<String, Object> objectToMap_inOrder_withoutFields(Object o, Collection<String> withoutFields) {
    if (o == null)
      return null;
    if (o instanceof Map)
      return (Map) o;
    LinkedHashMap<String, Object> map = new LinkedHashMap();
    for (String field : listWithoutSet(fieldsInOrder(o), withoutFields)) map.put(field, get(o, field));
    return map;
  }

  static public Map<String, Object> objectToMap(Object o) {
    try {
      if (o instanceof Map)
        return (Map) o;
      TreeMap<String, Object> map = new TreeMap();
      Class c = o.getClass();
      while (c != Object.class) {
        Field[] fields = c.getDeclaredFields();
        for (final Field field : fields) {
          if ((field.getModifiers() & Modifier.STATIC) != 0)
            continue;
          field.setAccessible(true);
          final Object value = field.get(o);
          if (value != null)
            map.put(field.getName(), value);
        }
        c = c.getSuperclass();
      }
      if (o instanceof DynamicObject)
        putAll(map, ((DynamicObject) o).fieldValues);
      return map;
    } catch (Exception __e) {
      throw rethrow(__e);
    }
  }

  static public List<Map<String, Object>> objectToMap(Iterable l) {
    if (l == null)
      return null;
    List x = new ArrayList();
    for (Object o : l) x.add(objectToMap(o));
    return x;
  }

  static public Map mapValues(Object func, Map map) {
    Map m = similarEmptyMap(map);
    for (Object key : keys(map)) m.put(key, callF(func, map.get(key)));
    return m;
  }

  static public <A, B, C> Map<A, C> mapValues(Map<A, B> map, IF1<B, C> f) {
    return mapValues(f, map);
  }

  static public <A, B, C> Map<A, C> mapValues(IF1<B, C> f, Map<A, B> map) {
    Map m = similarEmptyMap(map);
    for (Map.Entry<? extends A, ? extends B> __0 : _entrySet(map)) {
      A key = __0.getKey();
      B val = __0.getValue();
      m.put(key, f.get(val));
    }
    return m;
  }

  static public Map mapValues(Map map, Object func) {
    return mapValues(func, map);
  }

  static public JTable dataToTable_uneditable(Object data, final JTable table) {
    return dataToTable_uneditable(table, data);
  }

  static public JTable dataToTable_uneditable(final JTable table, final Object data) {
    if (table != null) {
      swing(() -> {
        dataToTable(table, data, true);
        makeTableUneditable(table);
      });
    }
    return table;
  }

  static public JTable dataToTable_uneditable(final Object data) {
    return dataToTable_uneditable(showTable(), data);
  }

  static public JTable dataToTable_uneditable(Object data, String title) {
    return dataToTable_uneditable(showTable(title), data);
  }

  static public boolean sexyTable_drag = false;

  static public JTable sexyTable() {
    final JTable table = sexyTableWithoutDrag();
    if (sexyTable_drag)
      tableEnableTextDrag(table);
    return table;
  }

  static public JTable onDoubleClickOrEnter(final JTable table, final Object runnable) {
    onDoubleClick(table, runnable);
    onEnter(table, runnable);
    return table;
  }

  static public JList onDoubleClickOrEnter(final JList list, final Object runnable) {
    onDoubleClick(list, runnable);
    onEnter(list, runnable);
    return list;
  }

  static public JTable onDoubleClickOrEnter(Object runnable, JTable table) {
    return onDoubleClickOrEnter(table, runnable);
  }

  static public class TableSearcher {

    public JTable table;

    public JTextField tfInput;

    public JComponent searchPanel, panel;

    public F2<String, Map, Boolean> rowTester;

    public List<Integer> rowIndices;

    public String input() {
      return gtt(tfInput);
    }
  }

  static public TableSearcher tableWithSearcher2(final JTable t, Object... __) {
    final TableSearcher s = new TableSearcher();
    final boolean precise = true;
    s.table = t;
    s.tfInput = jtextfield();
    s.rowTester = new F2<String, Map, Boolean>() {

      public Boolean get(String pat, Map row) {
        try {
          return anyValueContainsIgnoreCase(row, pat);
        } catch (Exception __e) {
          throw rethrow(__e);
        }
      }

      public String toString() {
        return "anyValueContainsIgnoreCase(row, pat)";
      }
    };
    onUpdate(s.tfInput, new Runnable() {

      public List lastFiltered, lastOriginal;

      public void run() {
        String pat = s.input();
        List<Map<String, Object>> data = rawTableData(t);
        if (eq(lastFiltered, data))
          data = lastOriginal;
        List data2 = new ArrayList();
        List<Integer> rowIndices = new ArrayList();
        for (int i = 0; i < l(data); i++) {
          Map<String, Object> map = data.get(i);
          if (isTrue(callF(s.rowTester, pat, map))) {
            data2.add(map);
            rowIndices.add(i);
          }
        }
        lastFiltered = data2;
        lastOriginal = data;
        dataToTable(t, data2);
        if (precise)
          lastFiltered = rawTableData(t);
        s.rowIndices = rowIndices;
      }
    });
    s.searchPanel = withLabel("Search:", s.tfInput);
    JComponent top = s.searchPanel;
    s.panel = boolOptPar(__, "withMargin") ? northAndCenterWithMargin(top, t) : northAndCenter(top, t);
    return s;
  }

  static public Point enclosingViewPosition(Component c) {
    JScrollPane sp = enclosingScrollPane(c);
    return sp == null ? null : swing(new F0<Point>() {

      public Point get() {
        try {
          return sp.getViewport().getViewPosition();
        } catch (Exception __e) {
          throw rethrow(__e);
        }
      }

      public String toString() {
        return "return sp.getViewport().getViewPosition();";
      }
    });
  }

  static public void setEnclosingViewPosition(Component c, Point p) {
    if (p == null)
      return;
    JScrollPane sp = enclosingScrollPane(c);
    if (sp != null) {
      swing(() -> {
        sp.getViewport().setViewPosition(p);
      });
    }
  }

  static public <A> void syncClear(Collection<A> c) {
    if (c != null)
      synchronized (collectionMutex(c)) {
        c.clear();
      }
  }

  static public void syncClear(Map map) {
    if (map != null)
      synchronized (collectionMutex(map)) {
        map.clear();
      }
  }

  static public <A> boolean syncAdd(Collection<A> c, A b) {
    if (c == null)
      return false;
    synchronized (collectionMutex(c)) {
      return c.add(b);
    }
  }

  static public <A> void syncAdd(List<A> l, int idx, A b) {
    if (l != null)
      synchronized (collectionMutex(l)) {
        l.add(idx, b);
      }
  }

  static public <A> boolean syncAddAll(Collection<A> c, Iterable<A> b) {
    if (c == null || b == null)
      return false;
    synchronized (c) {
      return c.addAll(asCollection(b));
    }
  }

  static public <A> boolean syncRemove(Collection<A> c, A b) {
    if (c == null)
      return false;
    synchronized (collectionMutex(c)) {
      return c.remove(b);
    }
  }

  static public <A> A syncRemove(List<A> l, int idx) {
    if (l == null)
      return null;
    synchronized (collectionMutex(l)) {
      return l.remove(idx);
    }
  }

  static public <A, B> B syncRemove(Map<A, B> map, A key) {
    return map == null ? null : map.remove(key);
  }

  static public <A> boolean syncRemoveAll(Collection<A> c, Collection<A> b) {
    if (c == null || b == null)
      return false;
    synchronized (collectionMutex(c)) {
      return c.removeAll(b);
    }
  }

  static public <A> void removeAll(Collection<A> a, Collection<A> b) {
    if (a != null && b != null)
      a.removeAll(b);
  }

  static public <A, B> void removeAll(Map<A, B> a, Collection<A> b) {
    if (a != null && b != null)
      for (A x : b) a.remove(x);
  }

  static public <A, B extends A> boolean removeAll(Collection<A> c, B... b) {
    return c != null && b != null && c.removeAll(Arrays.asList(b));
  }

  static public <A, B> void removeAll(Map<A, B> a, A... b) {
    if (a != null && b != null)
      for (A x : b) a.remove(x);
  }

  static public int[] selectedTableRows_array(final JTable table) {
    return table == null ? null : swing(new F0<int[]>() {

      public int[] get() {
        try {
          return table.getSelectedRows();
        } catch (Exception __e) {
          throw rethrow(__e);
        }
      }

      public String toString() {
        return "return table.getSelectedRows();";
      }
    });
  }

  static public void selectTableRows(final JTable table, int[] rows) {
    if (table != null) {
      swing(() -> {
        ListSelectionModel model = table.getSelectionModel();
        int n = tableRows(table);
        model.clearSelection();
        if (rows != null)
          for (int row : rows) if (row < n)
            model.addSelectionInterval(row, row);
      });
    }
  }

  static public <A> A syncGet(List<A> l, int idx) {
    if (l == null || idx < 0)
      return null;
    synchronized (l) {
      return idx < l(l) ? l.get(idx) : null;
    }
  }

  static public <A, B> B syncGet(Map<A, B> map, A a) {
    if (map == null)
      return null;
    synchronized (map) {
      return map.get(a);
    }
  }

  static public int selectedTableRowInModel(final JTable t) {
    return t == null ? -1 : swing(new F0<Integer>() {

      public Integer get() {
        try {
          int i = t.getSelectedRow();
          return i < 0 ? i : t.convertRowIndexToModel(i);
        } catch (Exception __e) {
          throw rethrow(__e);
        }
      }

      public String toString() {
        return "int i = t.getSelectedRow();\r\n    ret i < 0 ? i : t.convertRowIndexToModel(i);";
      }
    });
  }

  static public <A> List<A> syncListGetMulti(final List<A> l, List<Integer> indices) {
    synchronized (collectionMutex(l)) {
      return listGetMulti(l, indices);
    }
  }

  static public int selectedTableRow(final JTable t) {
    return t == null ? -1 : swing(new F0<Integer>() {

      public Integer get() {
        try {
          return t.getSelectedRow();
        } catch (Exception __e) {
          throw rethrow(__e);
        }
      }

      public String toString() {
        return "return t.getSelectedRow();";
      }
    });
  }

  static public List<Integer> selectedTableRowsInModel(final JTable t) {
    return t == null ? emptyList() : swing(new F0<List<Integer>>() {

      public List<Integer> get() {
        try {
          return map(selectedTableRows(t), i -> t.convertRowIndexToModel(i));
        } catch (Exception __e) {
          throw rethrow(__e);
        }
      }

      public String toString() {
        return "return map(selectedTableRows(t), i -> t.convertRowIndexToModel(i));";
      }
    });
  }

  static public JTable tablePopupMenuItemsThreaded(final JTable table, Object... params) {
    for (int i = 0; i + 1 < l(params); i += 2) {
      final Object action = params[i + 1];
      final Object threadInfo = _threadInfo();
      tablePopupMenuItem(table, str(params[i]), new VF1<Integer>() {

        public void get(final Integer row) {
          try {
            _threadInheritInfo(threadInfo);
            {
              startThread(new Runnable() {

                public void run() {
                  try {
                    try {
                      callF(action, row);
                    } catch (Throwable __e) {
                      messageBox(__e);
                    }
                  } catch (Exception __e) {
                    throw rethrow(__e);
                  }
                }

                public String toString() {
                  return "try {\r\n        callF(action, row);\r\n      } catch (Throwable __e) { messageBo...";
                }
              });
            }
          } catch (Exception __e) {
            throw rethrow(__e);
          }
        }

        public String toString() {
          return "_threadInheritInfo(threadInfo);\r\n      thread-messagebox {\r\n        callF(act...";
        }
      });
    }
    return table;
  }

  static public JTable tablePopupMenuItemsThreaded_top(final JTable table, Object... params) {
    params = reverseParams(params);
    for (int i = 0; i + 1 < l(params); i += 2) {
      final Object action = params[i + 1];
      final Object threadInfo = _threadInfo();
      tablePopupMenuItem_top(table, str(params[i]), new VF1<Integer>() {

        public void get(final Integer row) {
          try {
            _threadInheritInfo(threadInfo);
            {
              startThread(new Runnable() {

                public void run() {
                  try {
                    try {
                      callF(action, row);
                    } catch (Throwable __e) {
                      messageBox(__e);
                    }
                  } catch (Exception __e) {
                    throw rethrow(__e);
                  }
                }

                public String toString() {
                  return "try {\r\n        callF(action, row);\r\n      } catch (Throwable __e) { messageBo...";
                }
              });
            }
          } catch (Exception __e) {
            throw rethrow(__e);
          }
        }

        public String toString() {
          return "_threadInheritInfo(threadInfo);\r\n      thread-messagebox {\r\n        callF(act...";
        }
      });
    }
    return table;
  }

  static public <A, B extends A> void _addAll(Collection<A> c, Iterable<B> b) {
    addAll(c, b);
  }

  static public <A, B extends A> boolean _addAll(Collection<A> c, Collection<B> b) {
    return addAll(c, b);
  }

  static public <A, B extends A> boolean _addAll(Collection<A> c, B... b) {
    return addAll(c, b);
  }

  static public void scrollTableDownNow(final JTable table) {
    if (table != null) {
      swing(() -> {
        table.scrollRectToVisible(table.getCellRect(table.getRowCount() - 1, 0, true));
      });
    }
  }

  static public boolean eqOrEqic(boolean caseInsensitive, String a, String b) {
    return caseInsensitive ? eqic(a, b) : eq(a, b);
  }

  static public boolean containsLineBreak(String s) {
    return containsNewLine(s);
  }

  static public CharInToken charIndexToCharInToken(List<String> tok, int charIndex) {
    int i = 0, idx = 0, lTok;
    while (i < l(tok) && idx + (lTok = l(tok.get(i))) <= charIndex) {
      idx += lTok;
      i++;
    }
    return new CharInToken(tok, i, charIndex - idx);
  }

  static public boolean eqOneOf(Object o, Object... l) {
    for (Object x : l) if (eq(o, x))
      return true;
    return false;
  }

  static public List<String> stringsSortedByLength(Iterable<String> l) {
    return sortedByCalculatedField(l, new F1<String, Integer>() {

      public Integer get(String s) {
        try {
          return l(s);
        } catch (Exception __e) {
          throw rethrow(__e);
        }
      }

      public String toString() {
        return "l(s)";
      }
    });
  }

  static public List concatMap(Object f, Iterable l) {
    return concatLists(map(f, l));
  }

  static public List concatMap(Iterable l, Object f) {
    return concatMap(f, l);
  }

  static public List concatMap(Object f, Object[] l) {
    return concatLists(map(f, l));
  }

  static public List concatMap(Object[] l, Object f) {
    return concatMap(f, l);
  }

  static public <A, B, C extends Iterable<B>> List<B> concatMap(Iterable<A> l, IF1<A, C> f) {
    return concatMap(l, (Object) f);
  }

  static public <A, B, C extends Iterable<B>> List<B> concatMap(IF1<A, C> f, Iterable<A> l) {
    return concatMap(l, f);
  }

  static public <A, B, C extends Iterable<B>> List<B> concatMap(IF1<A, C> f, A[] l) {
    return concatMap((Object) f, l);
  }

  static public List<String> methodNames(Object o) {
    return allMethodNames(o);
  }

  static public <A, B> boolean containsKey(Map<A, B> map, A key) {
    return map != null && map.containsKey(key);
  }

  static public <A, B> Map<A, B> putOrCreate(Map<A, B> map, A key, B value) {
    if (map == null)
      map = new HashMap();
    map.put(key, value);
    return map;
  }

  static public <A extends Iterable> A pnl(A l) {
    return pnl("", l);
  }

  static public <A extends Iterable> A pnl(String prefix, A l) {
    printNumberedLines(prefix, l);
    return l;
  }

  static public <A> A[] pnl(A[] l) {
    return pnl("", l);
  }

  static public <A> A[] pnl(String prefix, A[] l) {
    printNumberedLines(prefix, l);
    return l;
  }

  static public <A extends Map> A pnl(A map) {
    printNumberedLines(map);
    return map;
  }

  static public <A extends Map> A pnl(String prefix, A map) {
    printNumberedLines(prefix, map);
    return map;
  }

  static public String pnl(String s) {
    printNumberedLines(lines(s));
    return s;
  }

  static public <A> MultiSet<A> pnl(MultiSet<A> ms) {
    pnl(ms == null ? null : ms.asMap());
    return ms;
  }

  static public <A, B> MultiMap<A, B> pnl(MultiMap<A, B> mm) {
    pnl(mm == null ? null : mm.asMap());
    return mm;
  }

  static public String nlLogic_text(Exp e) {
    return e == null ? null : e.text();
  }

  static public String nlLogic_text(IfThen r) {
    return r == null ? null : r.text();
  }

  static public Pt longToPt(long l) {
    return new Pt(firstIntFromLong(l), secondIntFromLong(l));
  }

  static public long ptToLong(Pt p) {
    return p == null ? -1 : intPairToLong(p.x, p.y);
  }

  static public long ptToLong(int x, int y) {
    return intPairToLong(x, y);
  }

  static public GridBagConstraints gridBagConstraints_hstack_1(int spacing) {
    GridBagConstraints gbc = new GridBagConstraints();
    gbc.weighty = 1;
    gbc.fill = GridBagConstraints.VERTICAL;
    gbc.gridheight = GridBagConstraints.REMAINDER;
    gbc.insets = new Insets(0, spacing / 2, 0, spacing / 2);
    return gbc;
  }

  static public GridBagConstraints gridBagConstraints_hstack_rest() {
    GridBagConstraints gbc = gridBagConstraints_hstack_1(0);
    gbc.weightx = 1;
    return gbc;
  }

  static public <A extends JLabel> A leftAlignLabel(final A a) {
    return setHorizontalAlignment(JLabel.LEFT, a);
  }

  static public int inc(AtomicInteger i) {
    return incAtomicInt(i);
  }

  static public int inc(AtomicInteger i, int delta) {
    return incAtomicInt(i, delta);
  }

  static public long inc(AtomicLong l) {
    return incAtomicLong(l);
  }

  static public long inc(AtomicLong l, long b) {
    return l.addAndGet(b);
  }

  static public int inc(IntVar v) {
    synchronized (v) {
      int val = v.get() + 1;
      v.set(val);
      return val;
    }
  }

  static public int parseDigit(char c) {
    return c >= '0' && c <= '9' ? c - '0' : 0;
  }

  static public int parseDigit(String s, int i) {
    return parseDigit(s.charAt(i));
  }

  static public Pt ptMinus(Pt a, Pt b) {
    if (b == null)
      return a;
    return new Pt(a.x - b.x, a.y - b.y);
  }

  static public String singleDigitBytesToString(ByteBuffer l) {
    if (l == null)
      return null;
    int n = l.size();
    char[] data = new char[n];
    for (int i = 0; i < n; i++) data[i] = (char) ('0' + ubyteToInt(l.get(i)) % 10);
    return str(data);
  }

  static public Pt origin() {
    return pt(0, 0);
  }

  static public int length(Object[] array) {
    return array == null ? 0 : array.length;
  }

  static public int length(List list) {
    return list == null ? 0 : list.size();
  }

  static public int length(String s) {
    return s == null ? 0 : s.length();
  }

  static public BufferedImage inputImage_image;

  static public BufferedImage inputImage() {
    if (inputImage_image != null)
      return inputImage_image;
    final ImageChooser ic = new ImageChooser();
    if (!showTitledForm_blocking("Please Choose Image To Work On", "", ic))
      throw fail("No input image selected");
    return ic.getImage();
  }

  static public RasterBars reproduceRasterBars(IBWIntegralImage ii) {
    var thinImage = scaledBWImageFromBWIntegralImage_withMeta(ii, 1, ii.getHeight());
    var streaks = streaksOfRepeatingElements(listFromFunction(thinImage.getHeight(), y -> thinImage.getInt(0, y)));
    return new RasterBars(ii.getWidth(), ii.getHeight(), streaks);
  }

  static public BWIntegralImage bwIntegralImage(BufferedImage img) {
    return bwIntegralImage(img, null);
  }

  static public BWIntegralImage bwIntegralImage(BufferedImage img, Decolorizer decolorizer) {
    return img == null ? null : new BWIntegralImage(img, decolorizer);
  }

  static public BWIntegralImage bwIntegralImage(BWImage img) {
    return img == null ? null : new BWIntegralImage(img);
  }

  static public <A> Value<A> value(A a) {
    return new Value<A>(a);
  }

  static public String sfuIndent(Object o) {
    return sfuIndent(Integer.MAX_VALUE, o);
  }

  static public String sfuIndent(int levels, Object o) {
    return indentedStructureForUser(levels, o);
  }

  static public BWImage gazelle22_borderImage(BWImage posterizedWithMeta) {
    PosterizeBWImage op = (PosterizeBWImage) (getMetaSrc(posterizedWithMeta));
    return gazelle22_borderImage(op.img, posterizedWithMeta, op.brightnessLevels);
  }

  static public BWImage gazelle22_borderImage(BWImage unposterized, BWImage posterized, int brightnessLevels) {
    assertSameSize(unposterized, posterized);
    int w = posterized.getWidth(), h = posterized.getHeight();
    BWImage out = new BWImage(w * 2 + 1, h * 2 + 1);
    int singleStep = iceil(doubleRatio(255, brightnessLevels - 1));
    for (int y = 0; y < h; y++) for (int x = 0; x < w; x++) {
      if (x < w - 1) {
        int posterizedContrast = absDiff(posterized.getInt(x, y), posterized.getInt(x + 1, y));
        float result;
        if (posterizedContrast != 0) {
          if (posterizedContrast > singleStep)
            result = 1f;
          else {
            int realContrast = absDiff(unposterized.getInt(x, y), unposterized.getInt(x + 1, y));
            result = floatRatio(realContrast, singleStep);
          }
          out.setPixel(x * 2 + 1, y * 2, result);
          out.setPixel(x * 2 + 1, y * 2 + 1, result);
        }
      }
      if (y < h - 1) {
        int posterizedContrast = absDiff(posterized.getInt(x, y), posterized.getInt(x, y + 1));
        float result;
        if (posterizedContrast != 0) {
          if (posterizedContrast > singleStep)
            result = 1f;
          else {
            int realContrast = absDiff(unposterized.getInt(x, y), unposterized.getInt(x + 1, y));
            result = floatRatio(realContrast, singleStep);
          }
          out.setPixel(x * 2, y * 2 + 1, result);
          out.setPixel(x * 2 + 1, y * 2 + 1, result);
        }
      }
    }
    return out;
  }

  static public BWImage scaledBWImageFromBWIntegralImage_withMeta(int w, BWIntegralImage img) {
    return scaledBWImageFromBWIntegralImage(img, w);
  }

  static public BWImage scaledBWImageFromBWIntegralImage_withMeta_height(int h, BWIntegralImage img) {
    return scaledBWImageFromBWIntegralImage(img, widthForHeight(img, h), h);
  }

  static public BWImage scaledBWImageFromBWIntegralImage_withMeta(BWIntegralImage img, int w) {
    return scaledBWImageFromBWIntegralImage_withMeta(img, w, heightForWidth(img, w));
  }

  static public BWImage scaledBWImageFromBWIntegralImage_withMeta(BWIntegralImage img, int w, int h) {
    return setMetaSrc(scaledBWImageFromBWIntegralImage(img, w, h), functionCall("scaledBWImageFromBWIntegralImage", img, w, h));
  }

  static public BWImage scaledBWImageFromBWIntegralImage_withMeta(int w, IBWIntegralImage img) {
    return scaledBWImageFromBWIntegralImage(img, w);
  }

  static public BWImage scaledBWImageFromBWIntegralImage_withMeta_height(int h, IBWIntegralImage img) {
    return scaledBWImageFromBWIntegralImage(img, widthForHeight(img, h), h);
  }

  static public BWImage scaledBWImageFromBWIntegralImage_withMeta(IBWIntegralImage img, int w) {
    return scaledBWImageFromBWIntegralImage_withMeta(img, w, heightForWidth(img, w));
  }

  static public BWImage scaledBWImageFromBWIntegralImage_withMeta(IBWIntegralImage img, int w, int h) {
    return setMetaSrc(scaledBWImageFromBWIntegralImage(img, w, h), functionCall("scaledBWImageFromBWIntegralImage", img, w, h));
  }

  static public BWImage posterizeBWImage_withMeta(int brightnessLevels, BWImage img) {
    PosterizeBWImage x = new PosterizeBWImage(brightnessLevels, img);
    x.run();
    return setMetaSrcUnlessSame(img, x.result, x);
  }

  static public Rect toRect_round(DoubleRect r) {
    if (r == null)
      return null;
    int x = iround(r.x), y = iround(r.y);
    return new Rect(x, y, iround(r.x2()) - x, iround(r.y2()) - y);
  }

  static public Rect scaleRect(Rect r, double factorX, double factorY) {
    return rectFromPoints(iround(r.x * factorX), iround(r.y * factorY), iround(r.x2() * factorX), iround(r.y2() * factorY));
  }

  static public Rect scaleRect(Rect r, double factor) {
    return scaleRect(r, factor, factor);
  }

  static public Rect scaleRect(double factor, Rect r) {
    return scaleRect(r, factor);
  }

  static public DoubleRect scaleRect(DoubleRect r, double factorX, double factorY) {
    return doubleRect(r.x * factorX, r.y * factorY, r.w * factorX, r.h * factorY);
  }

  static public DoubleRect scaleRect(double factorX, double factorY, DoubleRect r) {
    return scaleRect(r, factorX, factorY);
  }

  static public DoubleRect doubleRectFromPoints(double x1, double y1, double x2, double y2) {
    return new DoubleRect(x1, y1, x2 - x1, y2 - y1);
  }

  static public RuntimeException todo() {
    throw new RuntimeException("TODO");
  }

  static public RuntimeException todo(Object msg) {
    throw new RuntimeException("TODO: " + msg);
  }

  static public int lLongArray(long[] a) {
    return a == null ? 0 : a.length;
  }

  static public long[] resizeLongArray(long[] a, int n) {
    if (n == lLongArray(a))
      return a;
    long[] b = new long[n];
    arraycopy(a, 0, b, 0, Math.min(lLongArray(a), n));
    return b;
  }

  static public <A> ArrayList<Long> longArrayToList(long[] a) {
    if (a == null)
      return null;
    return longArrayToList(a, 0, a.length);
  }

  static public <A> ArrayList<Long> longArrayToList(long[] a, int from, int to) {
    if (a == null)
      return null;
    ArrayList<Long> l = new ArrayList<>(to - from);
    for (int i = from; i < to; i++) l.add(a[i]);
    return l;
  }

  static public <A> List<A> listFromFunction(int n, IF1<Integer, A> f) {
    return new RandomAccessAbstractList<A>() {

      public int size() {
        return n;
      }

      public A get(int i) {
        return f.get(i);
      }
    };
  }

  static public <A> List<A> listFromFunction(IF1<Integer, A> f, int n) {
    return listFromFunction(n, f);
  }

  static public <A extends Container> A addComponents(final A c, final Collection<? extends Component> components) {
    if (nempty(components)) {
      swing(() -> {
        for (Component comp : components) c.add(comp);
        revalidate(c);
      });
    }
    return c;
  }

  static public <A extends Container> A addComponents(final A c, Component... components) {
    return addComponents(c, asList(components));
  }

  static public int countComponents(Container c) {
    return numberOfChildren(c);
  }

  static public int dualLog(int i) {
    return 32 - Integer.numberOfLeadingZeros(max(0, i - 1));
  }

  static public <A> A listGetOrCreate(List<A> l, int i, Class<? extends A> c) {
    return listGetOrCreate(l, i, () -> nuInstance(c));
  }

  static public <A> A listGetOrCreate(List<A> l, int i, IF0<A> f) {
    if (l == null)
      return null;
    A a = get(l, i);
    if (a == null)
      listSet(l, i, a = f.get());
    return a;
  }

  static public <A> A listGetOrCreate(Class<? extends A> c, List<A> l, int i) {
    return listGetOrCreate(l, i, c);
  }

  static public IBWImage iBWImageFromFunction(IF2_IntInt_Double f, int w, int h) {
    return new IBWImage() {

      public int getWidth() {
        return w;
      }

      public int getHeight() {
        return h;
      }

      public float getFloatPixel(int x, int y) {
        return (float) f.get(x, y);
      }
    };
  }

  static public List<Integer> virtualCountList(int n) {
    return new RandomAccessAbstractList<Integer>() {

      public int size() {
        return n;
      }

      public Integer get(int i) {
        return i;
      }
    };
  }

  static public List<Integer> virtualCountList(int from, int to) {
    int n = max(to - from, 0);
    return new RandomAccessAbstractList<Integer>() {

      public int size() {
        return n;
      }

      public Integer get(int i) {
        return from + i;
      }
    };
  }

  static public IterableIterator<Integer> countIterator_inclusive_backwards(int a, int b) {
    return new IterableIterator<Integer>() {

      public int i = a;

      public boolean hasNext() {
        return i >= b;
      }

      public Integer next() {
        return i--;
      }
    };
  }

  static public <A> IterableIterator<A> countIterator_inclusive_backwards(int a, int b, IF1<Integer, A> f) {
    return mapI_if1(f, countIterator_inclusive_backwards(a, b));
  }

  static public <A> IterableIterator<A> iteratorFromFunction(final Object f) {
    class IFF extends IterableIterator<A> {

      public A a;

      public boolean done = false;

      public boolean hasNext() {
        getNext();
        return !done;
      }

      public A next() {
        getNext();
        if (done)
          throw fail();
        A _a = a;
        a = null;
        return _a;
      }

      public void getNext() {
        if (done || a != null)
          return;
        a = (A) callF(f);
        done = a == null;
      }
    }
    ;
    return new IFF();
  }

  static public <A> IterableIterator<A> iteratorFromFunction(F0<A> f) {
    return iteratorFromFunction_f0(f);
  }

  static public <A> IterableIterator<A> iteratorFromFunction(IF0<A> f) {
    return iteratorFromFunction_if0(f);
  }

  static public RGB rgbFromGrayscale(int brightness) {
    float f = RGB.brightnessToFloat(brightness);
    return new RGB(f, f, f);
  }

  static public String renderRecordVars(String recordName, Object... params) {
    List<String> l = new ArrayList();
    int i = 0;
    for (; i + 1 < l(params); i += 2) l.add(params[i] + "=" + params[i + 1]);
    return formatFunctionCall(recordName, l);
  }

  static public int done_minPrint = 10;

  static public long done(long startTime, String desc) {
    long time = now() - startTime;
    if (time >= done_minPrint)
      print(desc + " [" + time + " ms]");
    return time;
  }

  static public long done(String desc, long startTime) {
    return done(startTime, desc);
  }

  static public long done(long startTime) {
    return done(startTime, "");
  }

  static public <A> A printStackTrace_gen(A e) {
    if (e instanceof Throwable)
      printStackTrace((Throwable) e);
    else
      print(e);
    return e;
  }

  static public int lByteArray(byte[] a) {
    return a == null ? 0 : a.length;
  }

  static public byte[] resizeByteArray(byte[] a, int n) {
    if (n == l(a))
      return a;
    byte[] b = new byte[n];
    arraycopy(a, 0, b, 0, min(l(a), n));
    return b;
  }

  static public Object[] toArray(Collection c) {
    return toObjectArray(c);
  }

  static public <A> A[] toArray(Class<A> type, Iterable<A> c) {
    return toArray(c, type);
  }

  static public <A> A[] toArray(Iterable<A> c, Class<A> type) {
    A[] a = arrayOfType(l(c), type);
    if (a.length == 0)
      return a;
    asList(c).toArray(a);
    return a;
  }

  static public <A> A[] toArray(A[] array, Collection c) {
    if (array == null || c == null)
      return null;
    asList(c).toArray(array);
    return array;
  }

  static public <A> ArrayList<Byte> byteArrayToList(byte[] a) {
    if (a == null)
      return null;
    return byteArrayToList(a, 0, a.length);
  }

  static public <A> ArrayList<Byte> byteArrayToList(byte[] a, int from, int to) {
    if (a == null)
      return null;
    ArrayList<Byte> l = new ArrayList<>(to - from);
    for (int i = from; i < to; i++) l.add(a[i]);
    return l;
  }

  static public <A> A popFirst(List<A> l) {
    if (empty(l))
      return null;
    A a = first(l);
    l.remove(0);
    return a;
  }

  static public <A> A popFirst(Collection<A> l) {
    if (empty(l))
      return null;
    A a = first(l);
    l.remove(a);
    return a;
  }

  static public <A, B> Pair<A, B> popFirst(Map<A, B> map) {
    if (map == null)
      return null;
    var it = map.entrySet().iterator();
    if (!it.hasNext())
      return null;
    var p = mapEntryToPair(it.next());
    it.remove();
    return p;
  }

  static public <A> List<A> popFirst(int n, List<A> l) {
    List<A> part = cloneSubList(l, 0, n);
    removeSubList(l, 0, n);
    return part;
  }

  static public <A> AppendableChain<A> popFirst(AppendableChain<A> a) {
    return a == null ? null : a.popFirst();
  }

  static public <A> A nextToLast(List<A> l) {
    return get(l, l(l) - 2);
  }

  static public Pt toPt(Point p) {
    return p == null ? null : new Pt(p.x, p.y);
  }

  static public Pt toPt(Dimension d) {
    return d == null ? null : new Pt(d.width, d.width);
  }

  static public <A, B> MultiMap<A, B> descTreeMultiMap() {
    return new MultiMap(descTreeMap());
  }

  static public List<String> scoredSearch_prepare(String query) {
    return map(__72 -> replacePlusWithSpace(__72), splitAtSpace(query));
  }

  static public double scoredSearch_scoreWeighted2(Collection<Pair<String, Double>> l, List<String> words) {
    double score = 0;
    if (l != null)
      for (Pair<String, Double> __0 : l) {
        String s = pairA(__0);
        double weight = pairB(__0);
        score += scoredSearch_score(s, words) * weight;
      }
    return score;
  }

  static public int scoredSearch_score(Iterable<String> l, List<String> words) {
    int score = 0;
    if (l != null)
      for (String s : l) score += scoredSearch_score(s, words);
    return score;
  }

  static public int scoredSearch_score(String s, List<String> words) {
    int score = 0;
    if (nempty(s))
      for (String word : unnullForIteration(words)) score += scoredSearch_score_single(s, word);
    return score;
  }

  static public int scoredSearch_score(String s, String query) {
    return scoredSearch_score(s, scoredSearch_prepare(query));
  }

  static public <A, B> List<B> pairsB(Collection<Pair<A, B>> l) {
    return secondOfPairs(l);
  }

  static public <A, B> IterableIterator<Pair<A, B>> multiMapPairIterator(MultiMap<A, B> mm) {
    return nestedIterator(iterator(keys(mm.data)), key -> (IterableIterator<Pair<A, B>>) mapI(iterator(mm.data.get(key)), val -> pair(key, val)));
  }

  static public <A, B> IterableIterator<Pair<A, B>> multiMapPairIterator_transformValueList(MultiMap<A, B> mm, IF1<List<B>, List<B>> f) {
    return nestedIterator(iterator(keys(mm.data)), key -> (IterableIterator<Pair<A, B>>) mapI(iterator(f.get(mm.data.get(key))), val -> pair(key, val)));
  }

  static public <A, B> B firstValue(Map<A, B> map) {
    return first(values(map));
  }

  static public <A, B> B firstValue(MultiSetMap<A, B> map) {
    return map == null ? null : first(firstValue(map.data));
  }

  static public <A, B> B firstValue(MultiMap<A, B> map) {
    return map == null ? null : first(firstValue(map.data));
  }

  static public <A> void addWeakChangeListener(IHasChangeListeners src, A target, IVF1<A> action) {
    if (src == null || action == null || target == null)
      return;
    var ref = weakRef(target);
    src.onChange(new Runnable() {

      public void run() {
        try {
          var target = ref.get();
          if (target == null)
            src.removeChangeListener(this);
          else
            action.get(target);
        } catch (Exception __e) {
          throw rethrow(__e);
        }
      }

      public String toString() {
        return "var target = ref!;\r\n    if (target == null)\r\n      src.removeChangeListener(t...";
      }
    });
  }

  static public <A, B> Map<A, B> synchroIdentityHashMap() {
    return synchroMap(new IdentityHashMap());
  }

  static public <A, B> void mapPut2(Map<A, B> map, A key, B value) {
    if (map != null && key != null)
      if (value != null)
        map.put(key, value);
      else
        map.remove(key);
  }

  static public <A extends IMeta> A setMetaSrc(A a, Object src) {
    setMeta(a, "src", src);
    return a;
  }

  static public <A> A setMetaSrc(A a, Object src) {
    setMeta(a, "src", src);
    return a;
  }

  static public ImageSurface imageSurface(BufferedImage img) {
    return swingNu(ImageSurface.class, img);
  }

  static public ImageSurface imageSurface(MakesBufferedImage img) {
    return swingNu(ImageSurface.class, img);
  }

  static public ImageSurface imageSurface() {
    return swingNu(ImageSurface.class);
  }

  static public void imageSurface_pixelated(ImageSurface imageSurface) {
    if (imageSurface == null)
      return;
    imageSurface.setDoubleBuffered(true);
    imageSurface.noAlpha = true;
    imageSurface.interpolationMode = RenderingHints.VALUE_INTERPOLATION_NEAREST_NEIGHBOR;
    repaint(imageSurface);
  }

  static public void imageSurface_pixelated(ImageSurface imageSurface, boolean pixelated) {
    if (pixelated)
      imageSurface_pixelated(imageSurface);
    else
      imageSurface_unpixelated(imageSurface);
  }

  static public BufferedImage toBufferedImageOpt(Object o) {
    if (o instanceof BufferedImage)
      return ((BufferedImage) o);
    if (o instanceof Image)
      return copyImage((Image) o);
    if (o instanceof MakesBufferedImage)
      return ((MakesBufferedImage) o).getBufferedImage();
    if (o instanceof File)
      if (isImageFile((File) o))
        return loadBufferedImageFile((File) o);
    String c = getClassName(o);
    if (eqOneOf(c, "main$BWImage", "main$RGBImage"))
      return (BufferedImage) call(o, "getBufferedImage");
    if (eq(c, "main$PNGFile"))
      return (BufferedImage) call(o, "getImage");
    return null;
  }

  static public <A> A copyFields(Object x, A y, String... fields) {
    if (empty(fields)) {
      Map<String, Object> map = objectToMap(x);
      for (String field : map.keySet()) setOpt(y, field, map.get(field));
    } else
      for (String field : fields) {
        Object o = getOpt(x, field);
        if (o != null)
          setOpt(y, field, o);
      }
    return y;
  }

  static public <A> A copyFields(Object x, A y, Collection<String> fields) {
    return copyFields(x, y, asStringArray(fields));
  }

  static public Map<Class, Constructor> nuEmptyObject_cache = newDangerousWeakHashMap();

  static public <A> A nuEmptyObject(Class<A> c) {
    try {
      Constructor ctr;
      synchronized (nuEmptyObject_cache) {
        ctr = nuEmptyObject_cache.get(c);
        if (ctr == null) {
          nuEmptyObject_cache.put(c, ctr = nuEmptyObject_findConstructor(c));
          makeAccessible(ctr);
        }
      }
      try {
        return (A) ctr.newInstance();
      } catch (InstantiationException e) {
        if (empty(e.getMessage()))
          if ((c.getModifiers() & Modifier.ABSTRACT) != 0)
            throw fail("Can't instantiate abstract class " + className(c), e);
          else
            throw fail("Can't instantiate " + className(c), e);
        else
          throw rethrow(e);
      }
    } catch (Exception __e) {
      throw rethrow(__e);
    }
  }

  static public Constructor nuEmptyObject_findConstructor(Class c) {
    for (Constructor m : c.getDeclaredConstructors()) if (m.getParameterTypes().length == 0)
      return m;
    throw fail("No default constructor declared in " + c.getName());
  }

  static public <A> List<A> syncCloneAndClearList(Collection<A> l) {
    if (l == null)
      return emptyList();
    synchronized (collectionMutex(l)) {
      List<A> l2 = cloneList(l);
      l.clear();
      return l2;
    }
  }

  static public void cancelThread(Thread t) {
    if (t == null)
      return;
    ping();
    synchronized (ping_actions) {
      ping_actions.put(t, "cancelled");
      ping_anyActions = true;
    }
  }

  static public Font getFont(JComponent c) {
    return c == null ? null : swing(new F0<Font>() {

      public Font get() {
        try {
          return c.getFont();
        } catch (Exception __e) {
          throw rethrow(__e);
        }
      }

      public String toString() {
        return "return c.getFont();";
      }
    });
  }

  static public int toInt_checked(long l) {
    if (l != (int) l)
      throw fail("Too large for int: " + l);
    return (int) l;
  }

  static public <A> List<A> asSynchroList(Iterable<A> l) {
    return syncList(cloneList(l));
  }

  static public String lines_rtrim(Collection lines) {
    return rtrim_fromLines(lines);
  }

  static public BufferedImage cloneBufferedImageWithMetaSrc(Object src, BufferedImage img) {
    if (img == null)
      return null;
    img = cloneBufferedImageWithMeta(img);
    setMetaSrc(img, src);
    assertSame("cloneBufferedImageWithMetaSrc", getMetaSrc(img), src);
    return img;
  }

  static public void assertIsInstance(Class type, Object o) {
    if (!isInstance(type, o))
      throw fail(_getClass(o) + " is not a subclass of " + type);
  }

  static public void assertIsInstance(Object o, Class type) {
    assertIsInstance(type, o);
  }

  static public <A extends JLabel, B> A bindJLabelToTransformedLiveValue(IF1<B, Object> f, A label, LiveValue<B> lv) {
    bindLiveValueListenerToComponent(label, lv, () -> {
      setText(label, strOrNull(f.get(lv.get())));
    });
    return label;
  }

  static public int numberOfChildren(final Container c) {
    return c == null ? 0 : swing(new F0<Integer>() {

      public Integer get() {
        try {
          return c.getComponentCount();
        } catch (Exception __e) {
          throw rethrow(__e);
        }
      }

      public String toString() {
        return "return c.getComponentCount();";
      }
    });
  }

  static public void addDirectMenuItem(JMenuBar mb, String text, Object action) {
    if (mb != null) {
      swing(() -> {
        addDirectMenuItem(mb, directJMenuItem(text, action));
      });
    }
  }

  static public void addDirectMenuItem(Component c, String text, Object action) {
    addDirectMenuItem(addMenuBar(c), text, action);
  }

  static public void addDirectMenuItem(JMenuBar mb, JMenuItem menuItem) {
    if (mb != null) {
      swing(() -> {
        mb.add(menuItem);
        revalidate(mb);
      });
    }
  }

  static public void printVars_str(Object... params) {
    print(renderVars_str(params));
  }

  static public DynamicObject dynamicObject(String className, Object... x) {
    DynamicObject d = new DynamicObject(className);
    for (int i = 0; i < x.length - 1; i += 2) if (x[i + 1] != null)
      setDyn(d, (String) x[i], x[i + 1]);
    return d;
  }

  static public <A, B> B syncGetOrCreate(Map<A, B> map, A key, Class<? extends B> c) {
    try {
      synchronized (map) {
        return getOrCreate(map, key, c);
      }
    } catch (Exception __e) {
      throw rethrow(__e);
    }
  }

  static public <A, B> B syncGetOrCreate(Map<A, B> map, A key, Object f) {
    synchronized (map) {
      return getOrCreate(map, key, f);
    }
  }

  static public <A, B> B syncGetOrCreate(Class<? extends B> c, Map<A, B> map, A key) {
    return syncGetOrCreate(map, key, c);
  }

  static public <A, B> B syncGetOrCreate(Map<A, B> map, A key, IF0<B> f) {
    synchronized (map) {
      return getOrCreate(map, key, f);
    }
  }

  static public SingleThread awtCalcRegularly(JComponent component, int delay, int firstDelay, Object runnable) {
    final SingleThread thread = new SingleThread();
    final Runnable r2 = addThreadInfoToRunnable(runnable);
    final Object info = _threadInfo();
    installTimer(component, delay, firstDelay, new Runnable() {

      public void run() {
        if (!licensed())
          return;
        _threadInheritInfo(info);
        thread.go(r2);
      }
    });
    return thread;
  }

  static public SingleThread awtCalcRegularly(JFrame frame, int delay, int firstDelay, final Object runnable) {
    return awtCalcRegularly(getRootPane(frame), delay, firstDelay, runnable);
  }

  static public JTextArea showWrappedText(final String title, final String text) {
    return (JTextArea) swingAndWait(new F0<Object>() {

      public Object get() {
        try {
          JTextArea textArea = wrappedTextArea(text);
          caretToHome(textArea);
          textArea.setFont(typeWriterFont());
          makeFrame(title, new JScrollPane(textArea));
          return textArea;
        } catch (Exception __e) {
          throw rethrow(__e);
        }
      }

      public String toString() {
        return "JTextArea textArea = wrappedTextArea(text);\r\n    caretToHome(textArea);\r\n    ...";
      }
    });
  }

  static public JTextArea showWrappedText(Object text) {
    return showWrappedText(autoFrameTitle(), str(text));
  }

  static public Set<Thread> evalWithTimeout_inTime = synchroSet();

  static public Set<Thread> evalWithTimeout_allThreads = newWeakHashSet();

  static public ThreadLocal<String> evalWithTimeout_threadName = new ThreadLocal();

  static public <A> Either<A, Thread> evalWithTimeout(double timeoutSeconds, IF0<A> r) {
    return (Either) evalWithTimeout(timeoutSeconds, (Object) r);
  }

  static public Either<Object, Thread> evalWithTimeout(int timeoutMS, final Object r) {
    final Flag done = new Flag();
    final Flag doneWaiting = new Flag();
    final Var var = new Var();
    final Var<Throwable> error = new Var();
    Thread t = newThread(getAndClearThreadLocal(evalWithTimeout_threadName), new Runnable() {

      public void run() {
        try {
          try {
            try {
              var.set(callF(r));
            } finally {
              evalWithTimeout_allThreads.remove(currentThread());
            }
          } catch (Throwable e) {
            error.set(e);
            if (doneWaiting.isUp())
              printStackTrace_inPossiblyCancelledThread(e);
          } finally {
            done.raise();
          }
        } catch (Exception __e) {
          throw rethrow(__e);
        }
      }

      public String toString() {
        return "try {\r\n      try {\r\n        var.set(callF(r));\r\n      } finally {\r\n        ev...";
      }
    });
    beforeDelegatingToThread(t);
    try {
      startThread(t);
      evalWithTimeout_inTime.add(t);
      evalWithTimeout_allThreads.add(t);
      try {
        done.waitUntilUp(timeoutMS);
        doneWaiting.raise();
      } finally {
        evalWithTimeout_inTime.remove(t);
      }
      if (!done.isUp()) {
        print("Cancelling thread (timeout)");
        cancelAndInterruptThread(t);
        return either2(t);
      }
      if (error.get() != null)
        rethrow(error.get());
      return either1(var.get());
    } finally {
      afterDelegatingToThread(t);
    }
  }

  static public Either<Object, Thread> evalWithTimeout(double timeoutSeconds, final Object r) {
    return evalWithTimeout(toMS_int(timeoutSeconds), r);
  }

  static public String hijackPrint(Runnable r) {
    return hijackPrint((Object) r);
  }

  static public String hijackPrint(Object r) {
    final StringBuilder buf = new StringBuilder();
    Object old = interceptPrintInThisThread(new F1<String, Boolean>() {

      public Boolean get(String s) {
        buf.append(s);
        return false;
      }
    });
    try {
      callF(r);
      return str(buf);
    } finally {
      interceptPrintInThisThread(old);
    }
  }

  static public <A, B> Map<A, List<B>> multiMapToMap(MultiMap<A, B> m) {
    return m == null ? null : m.data;
  }

  static public <B> TreeMap<String, B> asCIMap(Map<String, B> map) {
    return asCaseInsensitiveMap(map);
  }

  static public Pt addPts(Pt a, Pt b) {
    return a == null ? b : b == null ? a : new Pt(a.x + b.x, a.y + b.y);
  }

  static public <A, B> WeakIdentityHashMap<A, B> weakIdentityHashMap() {
    return new WeakIdentityHashMap();
  }

  static public Object cloneWithoutField(Object o, String fieldToSkip) {
    try {
      if (o == null)
        return null;
      final Object clone = nuObject(o.getClass());
      Class c = o.getClass();
      while (c != Object.class) {
        Field[] fields = c.getDeclaredFields();
        for (final Field field : fields) {
          if (eq(field.getName(), fieldToSkip))
            continue;
          if ((field.getModifiers() & Modifier.STATIC) != 0)
            continue;
          field.setAccessible(true);
          field.set(clone, field.get(o));
        }
        c = c.getSuperclass();
      }
      return clone;
    } catch (Exception __e) {
      throw rethrow(__e);
    }
  }

  static public List<String> simpleSpaces(List<String> tok) {
    tok = cloneList(tok);
    for (int i = 0; i < l(tok); i += 2) tok.set(i, tok.get(i).equals("") ? "" : " ");
    return tok;
  }

  static public String simpleSpaces(String s) {
    return join(simpleSpaces(nlTok(s)));
  }

  static public String newLinesToSpaces(String s) {
    return s == null ? null : fixNewLines(s).replace("\n", " ");
  }

  static public void appendToLocalMechLog(String listName, String text) {
    logMechListAppendLocally(listName, text);
  }

  static public JButton jImageAndTextButton(String imageID, String text, Object action) {
    JButton btn = jImageAndTextButton_defaultPlacement(imageID, text, action);
    btn.setVerticalTextPosition(SwingConstants.BOTTOM);
    btn.setHorizontalTextPosition(SwingConstants.CENTER);
    return btn;
  }

  static public JButton jImageAndTextButton(String imageID, String text) {
    return jImageAndTextButton(imageID, text, null);
  }

  static public void resizeImageButtonToMax(final JButton b, final int max) {
    {
      swing(() -> {
        BufferedImage img = imageToBufferedImage(((ImageIcon) b.getIcon()).getImage());
        if (img == null)
          return;
        BufferedImage img2 = scaleBufferedImageToMaxWidthOrHeight(img, max);
        if (img2 != img)
          setButtonImage(img2, b);
      });
    }
  }

  static public int niceButtons_maxImageSize = 128;

  static public int niceButtons_maxImageSize() {
    return niceButtons_maxImageSize;
  }

  static public <A extends AbstractButton> A setVerticalTextPosition(final int pos, final A a) {
    if (a != null) {
      swing(() -> {
        a.setVerticalTextPosition(pos);
      });
    }
    return a;
  }

  static public <A extends JComponent> A setFontSize(final float size, final A a) {
    if (a == null)
      return a;
    {
      swing(() -> {
        a.setFont(a.getFont().deriveFont((float) size));
        if (a instanceof JComboBox) {
          Component _a = ((JComboBox) a).getEditor().getEditorComponent();
          if (_a instanceof JComponent)
            ((JComponent) _a).setFont(((JComponent) _a).getFont().deriveFont((float) size));
        }
      });
    }
    return a;
  }

  static public <A extends JComponent> A setFontSize(A a, float size) {
    return setFontSize(size, a);
  }

  static public <A extends AbstractButton> A setVerticalAlignment(final int pos, final A a) {
    if (a != null) {
      swing(() -> {
        a.setVerticalAlignment(pos);
      });
    }
    return a;
  }

  static public <A extends JLabel> A setVerticalAlignment(final int pos, final A a) {
    if (a != null) {
      swing(() -> {
        a.setVerticalAlignment(pos);
      });
    }
    return a;
  }

  static public void onMouseEnter(final Component c, final Object r) {
    if (c != null) {
      swing(() -> {
        c.addMouseListener(new MouseAdapter() {

          public void mouseEntered(MouseEvent e) {
            pcallF(r);
          }
        });
      });
    }
  }

  static public void onMouseExit(final Component c, final Object r) {
    if (c != null) {
      swing(() -> {
        c.addMouseListener(new MouseAdapter() {

          public void mouseExited(MouseEvent e) {
            pcallF(r);
          }
        });
      });
    }
  }

  static public List mapAndRecordToMap_reversed(Map recordMap, Iterable l, Object f) {
    return mapAndRecordToMap_reversed(recordMap, f, l);
  }

  static public List mapAndRecordToMap_reversed(Map recordMap, Object f, Iterable l) {
    List x = emptyList(l);
    if (l != null)
      for (Object o : l) {
        Object b = callF(f, o);
        if (recordMap != null)
          recordMap.put(b, o);
        x.add(b);
      }
    return x;
  }

  static public TextImageAction textImageActionToolTip(String text, String image, Object action, String toolTip) {
    TextImageAction t = new TextImageAction(text, image, action);
    t.toolTip = toolTip;
    return t;
  }

  static public void genericUI_openFile(File f) {
    appendToMechQ_withDate("User actions", "User clicked on file " + f2s(f));
    infoBox("TODO");
  }

  static public RGBImage loadImage(String snippetIDOrURL) {
    return new RGBImage(loadBufferedImage(snippetIDOrURL));
  }

  static public RGBImage loadImage(File f) {
    return new RGBImage(loadBufferedImage(f));
  }

  static public JFrame showPackedFrame(String title, Component contents) {
    return packFrame(showFrame(title, contents));
  }

  static public JFrame showPackedFrame(Component contents) {
    return packFrame(showFrame(contents));
  }

  static public Component frameIcon(Component c, String imageID) {
    setFrameIconLater(c, imageID);
    return c;
  }

  static public Component frameIcon(String imageID, Component c) {
    setFrameIconLater(c, imageID);
    return c;
  }

  static public JButton tableDependButton(JTable tbl, JButton b) {
    tableDependButtons(tbl, ll(b));
    return b;
  }

  static public JButton tableDependButton(JTable tbl, String text, Object action) {
    return tableDependButton(tbl, jbutton(text, action));
  }

  static public JTextField jTextField() {
    return jTextField("");
  }

  static public JTextField jTextField(final String text) {
    return swing(new F0<JTextField>() {

      public JTextField get() {
        try {
          JTextField tf = new JTextField(unnull(text));
          standardTextFieldPopupMenu(tf);
          jenableUndoRedo(tf);
          tf.selectAll();
          return tf;
        } catch (Exception __e) {
          throw rethrow(__e);
        }
      }

      public String toString() {
        return "JTextField tf = new JTextField(unnull(text));\r\n    standardTextFieldPopupMenu...";
      }
    });
  }

  static public JTextField jTextField(Object o) {
    return jTextField(strOrEmpty(o));
  }

  static public String conceptsFileName() {
    return "concepts.structure.gz";
  }

  static public long saveGZStructureToFile(String file, Object o) {
    return saveGZStructureToFile(getProgramFile(file), o);
  }

  static public long saveGZStructureToFile(File file, Object o) {
    return saveGZStructureToFile(file, o, new structure_Data());
  }

  static public long saveGZStructureToFile(File file, Object o, structure_Data data) {
    try {
      File parentFile = file.getParentFile();
      if (parentFile != null)
        parentFile.mkdirs();
      File tempFile = tempFileFor(file);
      if (tempFile.exists())
        try {
          String saveName = tempFile.getPath() + ".saved." + now();
          copyFile(tempFile, new File(saveName));
        } catch (Throwable e) {
          printStackTrace(e);
        }
      FileOutputStream fileOutputStream = newFileOutputStream(tempFile.getPath());
      CountingOutputStream cos;
      try {
        GZIPOutputStream gos = new GZIPOutputStream(fileOutputStream);
        cos = new CountingOutputStream(gos);
        OutputStreamWriter outputStreamWriter = new OutputStreamWriter(cos, "UTF-8");
        PrintWriter printWriter = new PrintWriter(outputStreamWriter);
        structureToPrintWriter(o, printWriter, data);
        printWriter.close();
        gos.close();
        fileOutputStream.close();
      } catch (Throwable e) {
        fileOutputStream.close();
        tempFile.delete();
        throw rethrow(e);
      }
      if (file.exists() && !file.delete())
        throw new IOException("Can't delete " + file.getPath());
      if (!tempFile.renameTo(file))
        throw new IOException("Can't rename " + tempFile + " to " + file);
      return cos.getFilePointer();
    } catch (Exception __e) {
      throw rethrow(__e);
    }
  }

  static public boolean all(Object pred, Iterable l) {
    if (l != null)
      for (Object o : l) if (!isTrue(callF(pred, o)))
        return false;
    return true;
  }

  static public <A> boolean all(Iterable<A> l, IF1<A, Boolean> f) {
    if (l != null)
      for (A a : l) if (!f.get(a))
        return false;
    return true;
  }

  static public <A> boolean all(IF1<A, Boolean> f, Iterable<A> l) {
    return all(l, f);
  }

  static public List<Character> characters(final String s) {
    return stringAsCharacterList(s);
  }

  static public boolean isValidFileCharacter(char c) {
    return isLetterOrDigit(c) || contains(".-_ %", c);
  }

  static public List<File> listDirs(File dir) {
    if (dir == null)
      return emptyList();
    File[] files = dir.listFiles();
    List<File> l = new ArrayList();
    if (files != null)
      for (File f : files) if (f.isDirectory())
        l.add(f);
    return l;
  }

  static public List<File> listDirs(String dir) {
    return listDirs(newFile(dir));
  }

  static public int methodApplicabilityScore_onTypes(Method m, Class[] argTypes) {
    return methodApplicabilityScore_onTypes((Executable) m, argTypes);
  }

  static public int methodApplicabilityScore_onTypes(Executable m, Class[] argTypes) {
    Class<?>[] types = m.getParameterTypes();
    if (types.length != argTypes.length)
      return Integer.MAX_VALUE;
    int score = 0;
    for (int i = 0; i < types.length; i++) {
      Class a = argTypes[i];
      Class c = types[i];
      if (c == a) {
      } else if (isSubclassOf(a, c))
        ++score;
      else
        return Integer.MAX_VALUE;
    }
    return score;
  }

  static public float clampZeroToOne(float x) {
    return x < 0 ? 0 : x > 1 ? 1 : x;
  }

  static public double clampZeroToOne(double x) {
    return x < 0 ? 0 : x > 1 ? 1 : x;
  }

  static public LookAndFeel currentLAF() {
    return UIManager.getLookAndFeel();
  }

  static public <A> void replaceLastElement(List<A> l, A a) {
    if (nempty(l))
      l.set(l(l) - 1, a);
  }

  static public String longestPrefixInNavigableSet(String s, NavigableSet<String> set) {
    if (set == null || s == null)
      return null;
    while (licensed()) {
      String key = set.floor(s);
      if (key == null)
        break;
      int n = lCommonPrefix(key, s);
      if (n == l(key))
        return key;
      s = takeFirst(s, n);
    }
    return null;
  }

  static public String shortenClassName(String name) {
    if (name == null)
      return null;
    int i = lastIndexOf(name, "$");
    if (i < 0)
      i = lastIndexOf(name, ".");
    return i < 0 ? name : substring(name, i + 1);
  }

  static public int latestInstalledJavaX() {
    File[] files = new File(userHome(), ".javax").listFiles();
    int v = 0;
    if (files != null)
      for (File f : files) {
        Matcher m = regexpMatcher("x(\\d\\d\\d?)\\.jar", f.getName());
        if (m.matches())
          v = Math.max(v, Integer.parseInt(m.group(1)));
      }
    return v;
  }

  static public String x30JarServerURL() {
    return "http://botcompany.de:8081/x30.jar";
  }

  static public Method findMethodNamed(Object obj, String method) {
    if (obj == null)
      return null;
    if (obj instanceof Class)
      return findMethodNamed((Class) obj, method);
    return findMethodNamed(obj.getClass(), method);
  }

  static public Method findMethodNamed(Class c, String method) {
    while (c != null) {
      for (Method m : c.getDeclaredMethods()) if (m.getName().equals(method)) {
        makeAccessible(m);
        return m;
      }
      c = c.getSuperclass();
    }
    return null;
  }

  static public int hashMap_internalHash(Object key) {
    int h;
    return (key == null) ? 0 : (h = key.hashCode()) ^ (h >>> 16);
  }

  static public void stepAllWithStats(Steppable s) {
    stepAllWithStats(s, null);
  }

  static public void stepAllWithStats(Steppable s, Long maxSteps) {
    if (s == null)
      return;
    long n = 0;
    long time = sysNow();
    if (maxSteps == null)
      while (s.step()) {
        ping();
        ++n;
      }
    else
      while (n < maxSteps && s.step()) {
        ping();
        ++n;
      }
    time = sysNow() - time;
    print(n2(n, "step") + " in " + n2(time) + " ms");
  }

  static public <A, B extends Collection<A>> B addAllAndReturnCollection(B c, Collection<A> b) {
    if (c != null && b != null)
      c.addAll(b);
    return c;
  }

  static public <A, B extends Collection<A>> B addAllAndReturnCollection(B c, A... b) {
    addAll(c, b);
    return c;
  }

  static public double toS(long ms) {
    return toSeconds(ms);
  }

  static public String toS(long ms, int digits) {
    return toSeconds(ms, digits);
  }

  static public JComponent withTitle(String title, Component c) {
    return withTitle(withTitle_titlePanel(title), c);
  }

  static public JComponent withTitle_titlePanel(String title) {
    return jlabel(title);
  }

  static public JPanel withTitle(final JComponent titleComponent, final Component c) {
    return swing(new F0<JPanel>() {

      public JPanel get() {
        try {
          titleComponent.setBorder(BorderFactory.createMatteBorder(0, 0, 1, 0, UIManager.getColor("Button.borderColor")));
          JPanel panel = new JPanel(new BorderLayout());
          panel.setBackground(Color.WHITE);
          panel.add(BorderLayout.NORTH, titleComponent);
          panel.add(BorderLayout.CENTER, wrap(c));
          return panel;
        } catch (Exception __e) {
          throw rethrow(__e);
        }
      }

      public String toString() {
        return "titleComponent.setBorder(BorderFactory.createMatteBorder(0, 0, 1, 0, UIManage...";
      }
    });
  }

  static public JLabel jCenteredBoldLabel(String text) {
    return jcenteredBoldLabel(text);
  }

  static public JLabel jCenteredBoldLabel() {
    return jcenteredBoldLabel();
  }

  static public JPanel northCenterAndSouth(Component n, Component c, Component s) {
    JPanel panel = new JPanel(new BorderLayout());
    panel.add(BorderLayout.NORTH, wrap(n));
    panel.add(BorderLayout.CENTER, wrap(c));
    panel.add(BorderLayout.SOUTH, wrap(s));
    return panel;
  }

  static public JLabel jCenteredLiveValueLabel(final LiveValue lv) {
    return centerLabel(jLiveValueLabel(lv));
  }

  static public JPanel jcenteredline(final Component... components) {
    return swing(new F0<JPanel>() {

      public JPanel get() {
        try {
          return jFullCenter(hstackWithSpacing(components));
        } catch (Exception __e) {
          throw rethrow(__e);
        }
      }

      public String toString() {
        return "return jFullCenter(hstackWithSpacing(components));";
      }
    });
  }

  static public JPanel jcenteredline(List<? extends Component> components) {
    return jcenteredline(asArray(Component.class, components));
  }

  static public AutoCloseable tempSetCustomRandomizerForThisThread(Random random) {
    return tempSetTL(customRandomizerForThisThread_tl(), random);
  }

  static public String errorIconID() {
    return "#1101390";
  }

  static public JComponent showErrorFrame(Throwable e) {
    return showText("Error", renderStackTrace((e)));
  }

  static public JLabel jlabel_noAutoToolTip() {
    return jlabel_noAutoToolTip(" ");
  }

  static public JLabel jlabel_noAutoToolTip(String text) {
    var lbl = swingConstruct(BetterLabel.class, text);
    lbl.autoToolTip = false;
    return lbl;
  }

  static public String exceptionType(Throwable e) {
    e = getInnerException(e);
    return shortClassName(e);
  }

  static public void addAndValidate(Container c, Component x) {
    if (c != null && x != null) {
      swing(() -> {
        if (c instanceof DynamicStack) {
          ((DynamicStack) c).addComponent(x);
          return;
        }
        c.add(x);
        c.revalidate();
      });
    }
  }

  static public BufferedImage img_addBorder(BufferedImage img, Color color, int border) {
    int top = border, bottom = border, left = border, right = border;
    int w = img.getWidth(), h = img.getHeight();
    BufferedImage img2 = createBufferedImage(left + w + right, top + h + bottom, color);
    Graphics2D g = img2.createGraphics();
    g.drawImage(img, left, top, null);
    g.dispose();
    return img2;
  }

  static public JLabel jImage(Image img) {
    return jimage(img);
  }

  static public JLabel jImage(String imageID) {
    return jimage(imageID);
  }

  static public BufferedImage resizeImageToHeight_bilinear(BufferedImage img, int newH) {
    return scaleImage_bilinear(doubleRatio(newH, img.getHeight()), img);
  }

  static public String join_flex(List<String> glues, Iterable<String> strings) {
    if (strings == null)
      return "";
    StringBuilder buf = new StringBuilder();
    Iterator<String> i = strings.iterator();
    Iterator<String> iGlues = glues.iterator();
    if (i.hasNext()) {
      buf.append(i.next());
      while (i.hasNext()) buf.append(iGlues.next()).append(i.next());
    }
    return buf.toString();
  }

  static public String a(String noun) {
    if (eq(noun, ""))
      return "?";
    return ("aeiou".indexOf(noun.charAt(0)) >= 0 ? "an " : "a ") + noun;
  }

  static public String a(String contents, Object... params) {
    return hfulltag("a", contents, params);
  }

  static public <A> TreeMap<String, A> caseInsensitiveMap() {
    return new TreeMap(caseInsensitiveComparator());
  }

  static public Class hotwireCoreSpecialMainClass(String mainClassName, List<File> files) {
    try {
      JavaXClassLoader classLoader = hotwire_makeClassLoader(files);
      Class<?> theClass = classLoader.loadClass(mainClassName);
      setOpt(theClass, "__javax", getJavaX());
      if (getOpt(theClass, "programID") == null)
        setOpt(theClass, "programID", "#3999999");
      if (!_inCore())
        hotwire_copyOver(theClass);
      return theClass;
    } catch (Exception __e) {
      throw rethrow(__e);
    }
  }

  static public String mapEachLine(IF1<String, String> f, String text) {
    return lines_possiblyRTrim(text, mapLines(f, text));
  }

  static public String mapEachLine(String text, IF1<String, String> f) {
    return mapEachLine(f, text);
  }

  static public List<String> regexpFirstGroups(String pat, String s) {
    if (s == null)
      return null;
    Matcher m = regexp(pat, s);
    return m.find() ? regexpGetGroups(m) : null;
  }

  static public IntRange intRangeWithLength(int start, int len) {
    return intRangeWithLen(start, len);
  }

  static public List<String> quoteAll(String[] l) {
    return quoteAll(asList(l));
  }

  static public List<String> quoteAll(Collection<String> l) {
    List<String> x = new ArrayList();
    for (String s : l) x.add(quote(s));
    return x;
  }

  static public String repSpace(int n) {
    return spaces(n);
  }

  static public void replaceTokens(List<String> tok, IntRange r, String s) {
    replaceTokens(tok, r.start, r.end, s);
  }

  static public void replaceTokens(List<String> tok, int i, int j, String s) {
    clearAllTokens(tok, i + 1, j);
    tok.set(i, s);
  }

  static public void replaceTokens(List<String> tok, String s) {
    clearAllTokens(tok, 1, l(tok));
    tok.set(0, s);
  }

  static public List<String> reTok_multi(List<String> tok, List<IntRange> places) {
    if (empty(places))
      return tok;
    if (l(places) == 1)
      return reTok(tok, first(places));
    List<String> orig = cloneList(tok);
    sortIntRangesInPlace(places);
    List<IntRange> places2 = new ArrayList();
    for (IntRange p : places) {
      p = intRange(p.start & ~1, p.end | 1);
      if (nempty(places2) && p.start <= last(places2).end)
        last(places2).end = p.end;
      else
        places2.add(p);
    }
    int iPlace = 0, n = l(orig);
    IntRange p = get(places2, iPlace);
    int next = p.start, i = next;
    tok.subList(next, tok.size()).clear();
    while (i < n) if (i < next)
      tok.add(orig.get(i++));
    else {
      int j = p.end;
      String s = joinSubList(orig, i, j);
      tok.addAll(javaTok(s));
      i = j;
      p = get(places2, ++iPlace);
      if (p == null)
        break;
      next = p.start;
    }
    while (i < n) tok.add(orig.get(i++));
    return tok;
  }

  static public <A> List<A> sortedByCalculatedField(Iterable<A> c, Object f) {
    return sortByCalculatedField(c, f);
  }

  static public <A> List<A> sortedByCalculatedField(Object f, Iterable<A> c) {
    return sortedByCalculatedField(c, f);
  }

  static public <A, B> List<A> sortedByCalculatedField(IF1<A, B> f, Iterable<A> c) {
    return sortedByCalculatedField(c, f);
  }

  static public <A, B> List<A> sortedByCalculatedField(Iterable<A> c, IF1<A, B> f) {
    List<A> l = cloneList(c);
    sort(l, new Comparator<A>() {

      public int compare(A a, A b) {
        return stdcompare(f.get(a), f.get(b));
      }
    });
    return l;
  }

  static public <A> Set<A> createOrAddToSet(Set<A> set, A a) {
    if (set == null)
      set = new HashSet();
    set.add(a);
    return set;
  }

  static public <A> Set<A> createOrAddToSet(Set<A> set, A... l) {
    for (A a : unnullForIteration(l)) set = createOrAddToSet(set, a);
    return set;
  }

  static public JTextField jLiveValueTextField_bothWays(final SimpleLiveValue<String> lv) {
    final JTextField ta = jTextField();
    bindTextComponentToLiveValue_bothWays(ta, lv);
    return ta;
  }

  static public float bwImageSimilarityResized(BWImage a, BWImage b, float similarityRequired) {
    int aw = a.w(), ah = a.h();
    int bw = b.w(), bh = b.h();
    int wp = max(aw, bw), hp = max(ah, bh);
    float ratio1 = ((float) aw) / ah, ratio2 = ((float) bw) / bh;
    float mismatch = ratio1 / ratio2;
    if (mismatch < 1f)
      mismatch = 1f / mismatch;
    float factor = wp * hp / mismatch;
    float maxError = (1f - similarityRequired) * factor;
    float diff = 0;
    for (int y = 0; y < hp; y++) for (int x = 0; x < wp; x++) {
      diff += Math.abs(a.getPixel(x * aw / wp, y * ah / hp) - b.getPixel(x * bw / wp, y * bh / hp));
      if (diff > maxError)
        return similarityRequired - 0.001f;
    }
    return 1f - diff / factor;
  }

  static public BWImage toBW(RGBImage img) {
    return img == null ? null : new BWImage(img);
  }

  static public String formatDoubleFull(double d, int digits) {
    String format = digits <= 0 ? "0" : "0." + rep(digits, '0');
    return new java.text.DecimalFormat(format, new java.text.DecimalFormatSymbols(Locale.ENGLISH)).format(d);
  }

  static public File[] listFiles(File dir) {
    File[] files = dir.listFiles();
    return files == null ? new File[0] : files;
  }

  static public File[] listFiles(String dir) {
    return listFiles(new File(dir));
  }

  static public String reversedString(String s) {
    return reverseString(s);
  }

  static public boolean rectsIntersect(Rect a, Rect b) {
    return rectsOverlap(a, b);
  }

  static public Rect boundsInParent(Component c, Class<? extends Component> parentType) {
    return boundsInParent(c, parentOfType(c, parentType));
  }

  static public Rect boundsInParent(Component _c, Component parent) {
    if (_c == null)
      return null;
    return swing(new F0<Rect>() {

      public Rect get() {
        try {
          if (_c == parent)
            return new Rect(0, 0, _c.getWidth(), _c.getHeight());
          Rect r = toRect(_c.getBounds());
          Component c = _c;
          while (true) {
            c = c.getParent();
            if (c == null)
              return null;
            if (c == parent)
              return r;
            r = translateRect(r, c.getX(), c.getY());
          }
        } catch (Exception __e) {
          throw rethrow(__e);
        }
      }

      public String toString() {
        return "if (_c == parent) ret Rect(0, 0, _c.getWidth(), _c.getHeight());\r\n    Rect r ...";
      }
    });
  }

  static public BufferedImage scaleBufferedImageToMax(int max, BufferedImage img) {
    return scaleBufferedImageToMaxWidthOrHeight(max, img);
  }

  static public BufferedImage scaleBufferedImageToMax(BufferedImage img, int max) {
    return scaleBufferedImageToMaxWidthOrHeight(img, max);
  }

  static public BufferedImage scaleBufferedImageToHeight(int height, BufferedImage img) {
    return scaleImage(img, height / (double) img.getHeight());
  }

  static public ClassLoader getClassLoader(Object o) {
    return o == null ? null : _getClass(o).getClassLoader();
  }

  static public boolean dirOrZipContainsPath(File location, String subPath) {
    try {
      if (location.isDirectory()) {
        return new File(location, subPath).exists();
      } else if (location.isFile()) {
        return zipFileContains_falseOnError(location, subPath);
      }
      return false;
    } catch (Exception __e) {
      throw rethrow(__e);
    }
  }

  static public List<String> loadedJigsawModuleNames() {
    var moduleLayer = ModuleLayer.boot();
    var modules = moduleLayer.modules();
    return map(modules, mod -> mod.getName());
  }

  static public List<String> classNamesInJigsawModule(String moduleName) {
    return classNamesInJigsawModule(moduleName, javaHome());
  }

  static public List<String> classNamesInJigsawModule(String moduleName, File javaHome) {
    return classNamesInJarOrDir(jigsawModuleFile(moduleName, javaHome), "classes/");
  }

  static public Class main() {
    return getMainClass();
  }

  static public ThreadLocal<Boolean> imageGraphics_antiAlias = new ThreadLocal();

  static public Graphics2D imageGraphics(BufferedImage img) {
    return !isFalse(imageGraphics_antiAlias.get()) ? antiAliasGraphics(img) : createGraphics(img);
  }

  static public <A extends Concept> A registerConcept(A c) {
    return registerConcept(db_mainConcepts(), c);
  }

  static public <A extends Concept> A registerConcept(Concepts cc, A c) {
    {
      if (cc != null)
        cc.register(c);
    }
    return c;
  }

  static public <A, B> List<B> lookupAllOpt(Map<A, B> map, Collection<A> l) {
    List<B> out = new ArrayList();
    if (l != null)
      for (A a : l) addIfNotNull(out, map.get(a));
    return out;
  }

  static public <A, B> List<B> lookupAllOpt(Collection<A> l, Map<A, B> map) {
    return lookupAllOpt(map, l);
  }

  static public <A, B extends IF0<A>> List<A> getVars(Iterable<B> l) {
    return lambdaMap(__73 -> getVar(__73), l);
  }

  static public <A> ArrayList<A> cloneList_noSync(Iterable<A> l) {
    return l instanceof Collection ? cloneList_noSync((Collection) l) : asList(l);
  }

  static public <A> ArrayList<A> cloneList_noSync(Collection<A> l) {
    if (l == null)
      return new ArrayList();
    return new ArrayList<A>(l);
  }

  static public <A, B> IterableIterator<B> concurrentlyIterateValues(NavigableMap<A, B> map) {
    return concurrentlyIterateValues(map, map);
  }

  static public <A, B> IterableIterator<B> concurrentlyIterateValues(final NavigableMap<A, B> map, Object mutex) {
    return iteratorFromFunction(new F0<B>() {

      public Iterator<A> it = keys(map).iterator();

      public A key;

      public B get() {
        synchronized (mutex) {
          try {
            if (!it.hasNext())
              return null;
            return map.get(key = it.next());
          } catch (ConcurrentModificationException e) {
            print("Re-iterating");
            it = map.tailMap(key, false).keySet().iterator();
            if (!it.hasNext())
              return null;
            return map.get(key = it.next());
          }
        }
      }
    });
  }

  static public Map mapKeys(Object func, Map map) {
    Map m = similarEmptyMap(map);
    for (Object key : keys(map)) m.put(callF(func, key), map.get(key));
    return m;
  }

  static public Map mapKeys(Map map, Object func) {
    return mapKeys(func, map);
  }

  static public <A, B, C> Map<B, C> mapKeys(Map<A, C> map, IF1<A, B> func) {
    return mapKeys(map, (Object) func);
  }

  static public <A, B, C> Map<B, C> mapKeys(IF1<A, B> func, Map<A, C> map) {
    return mapKeys(map, func);
  }

  static public <A> List<A> listWithoutSet(Collection<A> l, Collection<A> stuff) {
    return listMinusSet(l, stuff);
  }

  static public Map<Class, List<String>> fieldsInOrder_cache = weakHashMap();

  static public List<String> fieldsInOrder(Object o) {
    return fieldsInOrder(_getClass(o));
  }

  static public List<String> fieldsInOrder(Class c) {
    if (c == null)
      return null;
    synchronized (fieldsInOrder_cache) {
      List<String> fields = fieldsInOrder_cache.get(c);
      if (fields != null)
        return fields;
      String order = toStringOpt(getOpt(c, "_fieldOrder"));
      Set<String> set = asTreeSet(allNonStaticFields(c));
      if (order == null)
        return asList(set);
      fields = splitAtSpace(order);
      setAddAll(fields, set);
      fieldsInOrder_cache.put(c, fields);
      return fields;
    }
  }

  static public JTable dataToTable(Object data) {
    return dataToTable(showTable(), data);
  }

  static public JTable dataToTable(Object data, String title) {
    return dataToTable(showTable(title), data);
  }

  static public JTable dataToTable(JTable table, Object data) {
    return dataToTable(table, data, false);
  }

  static public JTable dataToTable(JTable table, Object data, boolean now) {
    List<List> rows = new ArrayList();
    List<String> cols = new ArrayList();
    if (data instanceof List) {
      for (Object x : (List) data) {
        try {
          rows.add(dataToTable_makeRow(x, cols));
        } catch (Throwable __e) {
          printStackTrace(__e);
        }
      }
    } else if (data instanceof Map) {
      Map map = (Map) data;
      for (Object key : map.keySet()) {
        Object value = map.get(key);
        rows.add(litlist(structureOrTextForUser(key), structureOrTextForUser(value)));
      }
    } else if (data != null)
      print("Unknown data type: " + data);
    fillTableWithData(table, rows, cols);
    return table;
  }

  static public void makeTableUneditable(JTable table) {
    for (int c = 0; c < table.getColumnCount(); c++) {
      Class<?> col_class = table.getColumnClass(c);
      table.setDefaultEditor(col_class, null);
    }
  }

  static public boolean showTable_searcher = true;

  static public JTable showTable(Object data) {
    return dataToTable_uneditable(data);
  }

  static public JTable showTable(String title, Object data) {
    return showTable(data, title);
  }

  static public JTable showTable(Object data, String title) {
    return dataToTable_uneditable(data, title);
  }

  static public JTable showTable(JTable table, Object data) {
    return showTable(table, data, autoFrameTitle());
  }

  static public JTable showTable(Object data, JTable table) {
    return showTable(table, data);
  }

  static public JTable showTable(JTable table, Object data, String title) {
    if (table == null)
      table = showTable(data, title);
    else {
      setFrameTitle(table, title);
      dataToTable_uneditable(table, data);
    }
    return table;
  }

  static public JTable showTable() {
    return showTable(new ArrayList<List<String>>(), new ArrayList<String>());
  }

  static public JTable showTable(String title) {
    return showTable(new ArrayList<List<String>>(), new ArrayList<String>(), title);
  }

  static public JTable showTable(List<List<String>> rows, List<String> cols) {
    return showTable(rows, cols, autoFrameTitle());
  }

  static public JTable showTable(List<List<String>> rows, List<String> cols, String title) {
    JTable tbl = sexyTable();
    fillTableWithStrings(tbl, rows, cols);
    showFrame(title, tbl);
    return tbl;
  }

  static public void tableEnableTextDrag(final JTable table) {
    TransferHandler th = new TransferHandler() {

      @Override
      public int getSourceActions(JComponent c) {
        return COPY;
      }

      @Override
      public Transferable createTransferable(JComponent c) {
        Object o = selectedTableCell(table);
        return new StringSelection(str(o));
      }
    };
    tableEnableDrag(table, th);
  }

  static public JList onDoubleClick(final JList list, final Object runnable) {
    {
      swing(() -> {
        list.addMouseListener(new MouseAdapter() {

          public void mouseClicked(MouseEvent evt) {
            if (evt.getClickCount() == 2) {
              int idx = list.locationToIndex(evt.getPoint());
              Object item = list.getModel().getElementAt(idx);
              list.setSelectedIndex(idx);
              callF(runnable, item);
            }
          }
        });
      });
    }
    return list;
  }

  static public JTable onDoubleClick(final JTable table, final Object runnable) {
    {
      swing(() -> {
        table.addMouseListener(new MouseAdapter() {

          public void mouseClicked(MouseEvent evt) {
            if (evt.getClickCount() == 2) {
              int idx = table.rowAtPoint(evt.getPoint());
              table.setRowSelectionInterval(idx, idx);
              callF(runnable, idx);
            }
          }
        });
      });
    }
    return table;
  }

  static public void onDoubleClick(final JComponent c, final Object runnable) {
    {
      swing(() -> {
        c.addMouseListener(new MouseAdapter() {

          public void mouseClicked(MouseEvent evt) {
            if (evt.getButton() == 1 && evt.getClickCount() == 2)
              callF(runnable, evt.getPoint());
          }
        });
      });
    }
  }

  static public String gtt(JTextComponent c) {
    return getTextTrim(c);
  }

  static public String gtt(JComboBox cb) {
    return getTextTrim(cb);
  }

  static public boolean anyValueContainsIgnoreCase(Map map, String pat) {
    for (Object val : values(map)) if (val instanceof String && containsIgnoreCase((String) val, pat))
      return true;
    return false;
  }

  static public List<Map<String, Object>> rawTableData(JTable t) {
    int n = tableRows(t);
    List l = new ArrayList();
    for (int i = 0; i < n; i++) l.add(rawTableLineAsMap(t, i));
    return l;
  }

  static public boolean boolOptPar(ThreadLocal<Boolean> tl) {
    return boolOptParam(tl);
  }

  static public boolean boolOptPar(Object[] __, String name) {
    return boolOptParam(__, name);
  }

  static public boolean boolOptPar(String name, Object[] __) {
    return boolOptParam(__, name);
  }

  static public <A> Collection<A> asCollection(Iterable<A> l) {
    return l == null ? null : l instanceof Collection ? ((Collection) l) : asList(l);
  }

  static public int tableRows(JTable table) {
    return (int) swingCall(table, "getRowCount");
  }

  static public <A> List<A> listGetMulti(final List<A> l, List<Integer> indices) {
    return map(indices, new F1<Integer, A>() {

      public A get(Integer i) {
        try {
          return _get(l, i);
        } catch (Exception __e) {
          throw rethrow(__e);
        }
      }

      public String toString() {
        return "_get(l, i)";
      }
    });
  }

  static public List<Integer> selectedTableRows(final JTable table) {
    return table == null ? null : swing(new F0<List<Integer>>() {

      public List<Integer> get() {
        try {
          return asList(table.getSelectedRows());
        } catch (Exception __e) {
          throw rethrow(__e);
        }
      }

      public String toString() {
        return "return asList(table.getSelectedRows());";
      }
    });
  }

  static public void tablePopupMenuItem(JTable table, String name, Object action) {
    tablePopupMenu(table, new VF2<JPopupMenu, Integer>() {

      public void get(JPopupMenu menu, final Integer row) {
        try {
          addMenuItem(menu, name, new Runnable() {

            public void run() {
              try {
                pcallF(action, row);
              } catch (Exception __e) {
                throw rethrow(__e);
              }
            }

            public String toString() {
              return "pcallF(action, row)";
            }
          });
        } catch (Exception __e) {
          throw rethrow(__e);
        }
      }

      public String toString() {
        return "addMenuItem(menu, name, r { pcallF(action, row) });";
      }
    });
  }

  static public void tablePopupMenuItem(JTable table, String name, IVF1<Integer> action) {
    tablePopupMenuItem(table, name, (Object) action);
  }

  static public Object[] reverseParams(Object[] params) {
    int n = l(params);
    if (params == null || odd(n))
      return params;
    Object[] a = new Object[n];
    for (int i = 0; i + 1 < n; i += 2) arraycopy(params, i, a, n - i - 2, 2);
    return a;
  }

  static public void tablePopupMenuItem_top(final JTable table, final String name, final Object action) {
    tablePopupMenuFirst(table, new VF2<JPopupMenu, Integer>() {

      public void get(JPopupMenu menu, final Integer row) {
        try {
          addMenuItem(menu, name, new Runnable() {

            public void run() {
              try {
                pcallF(action, row);
              } catch (Exception __e) {
                throw rethrow(__e);
              }
            }

            public String toString() {
              return "pcallF(action, row)";
            }
          });
        } catch (Exception __e) {
          throw rethrow(__e);
        }
      }

      public String toString() {
        return "addMenuItem(menu, name, r { pcallF(action, row) });";
      }
    });
  }

  static public void printNumberedLines(Map map) {
    printNumberedLines(mapToLines(map));
  }

  static public void printNumberedLines(String prefix, Map map) {
    printNumberedLines(prefix, mapToLines(map));
  }

  static public <A extends Iterable> A printNumberedLines(A l) {
    int i = 0;
    if (l != null)
      for (Object a : cloneList(l)) print((++i) + ". " + str(a));
    return l;
  }

  static public <A extends Iterable> A printNumberedLines(String prefix, A l) {
    int i = 0;
    if (l != null)
      for (Object a : cloneList(l)) print(prefix + (++i) + ". " + str(a));
    return l;
  }

  static public void printNumberedLines(Object[] l) {
    printNumberedLines("", l);
  }

  static public void printNumberedLines(String prefix, Object[] l) {
    printNumberedLines(prefix, wrapAsList(l));
  }

  static public void printNumberedLines(Object o) {
    printNumberedLines(lines(str(o)));
  }

  static public int firstIntFromLong(long l) {
    return (int) (l >> 32);
  }

  static public int secondIntFromLong(long l) {
    return (int) l;
  }

  static public long intPairToLong(IntPair p) {
    return p == null ? 0 : (((long) p.a) << 32) | (((long) p.b) & 0xFFFFFFFF);
  }

  static public long intPairToLong(int a, int b) {
    return (((long) a) << 32) | (((long) b) & 0xFFFFFFFF);
  }

  static public int incAtomicInt(AtomicInteger i) {
    return i.incrementAndGet();
  }

  static public int incAtomicInt(AtomicInteger i, int delta) {
    return i.addAndGet(delta);
  }

  static public boolean showTitledForm_blocking(String title, Object... _parts) {
    assertNotOnAWTThread();
    final Var<Boolean> var = new Var();
    onFrameClose(showFormTitled(title, arrayPlus(_parts, new Runnable() {

      public void run() {
        try {
          var.set(true);
        } catch (Exception __e) {
          throw rethrow(__e);
        }
      }

      public String toString() {
        return "var.set(true)";
      }
    })), new Runnable() {

      public void run() {
        try {
          if (!var.has())
            var.set(false);
        } catch (Exception __e) {
          throw rethrow(__e);
        }
      }

      public String toString() {
        return "if (!var.has()) var.set(false)";
      }
    });
    waitUntilVarSet(var);
    return var.get();
  }

  static public <A> List<Pair<IntRange, A>> streaksOfRepeatingElements(List<A> l) {
    List<Pair<IntRange, A>> out = new ArrayList();
    int i = 0, n = l(l);
    while (i < n) {
      A a = l.get(i);
      int j = i + 1;
      while (j < n && eq(a, l.get(j))) ++j;
      out.add(pair(intRange(i, j), a));
      i = j;
    }
    return out;
  }

  static public String indentedStructureForUser(Object o) {
    return indentedStructureForUser(Integer.MAX_VALUE, o);
  }

  static public String indentedStructureForUser(int levels, Object o) {
    return indentStructureString(levels, structForUser(o));
  }

  static public float floatRatio(float x, float y) {
    return y == 0 ? 0 : x / y;
  }

  static public BWImage scaledBWImageFromBWIntegralImage(int w, BWIntegralImage img) {
    return scaledBWImageFromBWIntegralImage(img, w);
  }

  static public BWImage scaledBWImageFromBWIntegralImage(BWIntegralImage img, int w) {
    return scaledBWImageFromBWIntegralImage(img, w, heightForWidth(img, w));
  }

  static public BWImage scaledBWImageFromBWIntegralImage(BWIntegralImage img, int w, int h) {
    byte[] pixels = scaledGrayBytesFromBWIntegralImage(img, w, h);
    return new BWImage(w, h, pixels);
  }

  static public BWImage scaledBWImageFromBWIntegralImage(int w, IBWIntegralImage img) {
    return scaledBWImageFromBWIntegralImage(img, w);
  }

  static public BWImage scaledBWImageFromBWIntegralImage(IBWIntegralImage img, int w) {
    return scaledBWImageFromBWIntegralImage(img, w, heightForWidth(img, w));
  }

  static public BWImage scaledBWImageFromBWIntegralImage(IBWIntegralImage img, int w, int h) {
    byte[] pixels = scaledGrayBytesFromBWIntegralImage(img, w, h);
    return new BWImage(w, h, pixels);
  }

  static public <A extends IMeta> A setMetaSrcUnlessSame(Object b, A a, Object src) {
    if (a != b)
      setMeta(a, "src", src);
    return a;
  }

  static public DoubleRect doubleRect(double w, double h) {
    return new DoubleRect(0, 0, w, h);
  }

  static public DoubleRect doubleRect(double x, double y, double w, double h) {
    return new DoubleRect(x, y, w, h);
  }

  static public <A> A nuInstance(Class<A> c) {
    return nuEmptyObject(c);
  }

  static public <A> IterableIterator<A> iteratorFromFunction_f0(final F0<A> f) {
    class IFF2 extends IterableIterator<A> {

      public A a;

      public boolean done = false;

      public boolean hasNext() {
        getNext();
        return !done;
      }

      public A next() {
        getNext();
        if (done)
          throw fail();
        A _a = a;
        a = null;
        return _a;
      }

      public void getNext() {
        if (done || a != null)
          return;
        a = f.get();
        done = a == null;
      }
    }
    ;
    return new IFF2();
  }

  static public <A> IterableIterator<A> iteratorFromFunction_if0(final IF0<A> f) {
    class IFF2 extends IterableIterator<A> {

      public A a;

      public boolean done = false;

      public boolean hasNext() {
        getNext();
        return !done;
      }

      public A next() {
        getNext();
        if (done)
          throw fail();
        A _a = a;
        a = null;
        return _a;
      }

      public void getNext() {
        if (done || a != null)
          return;
        a = f.get();
        done = a == null;
      }
    }
    ;
    return new IFF2();
  }

  static public TreeMap descTreeMap() {
    return revTreeMap();
  }

  static public String replacePlusWithSpace(String s) {
    return replace(s, '+', ' ');
  }

  static public <A, B> B pairB(Pair<A, B> p) {
    return p == null ? null : p.b;
  }

  static public int scoredSearch_score_single(String s, String query) {
    int i = indexOfIC_underscore(s, query);
    if (i < 0)
      return 0;
    if (i > 0)
      return 1;
    return l(s) == l(query) ? 3 : 2;
  }

  static public <A, B> List<B> secondOfPairs(Collection<Pair<A, B>> l) {
    return lambdaMap(__74 -> secondOfPair(__74), l);
  }

  static public class mapI_It extends IterableIterator {

    public Object f;

    public Iterator i;

    public mapI_It() {
    }

    public mapI_It(Object f, Iterator i) {
      this.i = i;
      this.f = f;
    }

    public boolean hasNext() {
      return i.hasNext();
    }

    public Object next() {
      return callF(f, i.next());
    }

    public String toString() {
      return formatFunctionCall("mapI", f, i);
    }
  }

  static public IterableIterator mapI(final Object f, final Iterator i) {
    return new mapI_It(f, i);
  }

  static public IterableIterator mapI(IterableIterator i, Object f) {
    return mapI((Iterator) i, f);
  }

  static public IterableIterator mapI(Object f, IterableIterator i) {
    return mapI((Iterator) i, f);
  }

  static public IterableIterator mapI(Iterator i, Object f) {
    return mapI(f, i);
  }

  static public <A, B> IterableIterator<B> mapI(Iterable<A> i, IF1<A, B> f) {
    return mapI(i, (Object) f);
  }

  static public <A, B> IterableIterator<B> mapI(Iterator<A> i, IF1<A, B> f) {
    return mapI(f, i);
  }

  static public <A, B> IterableIterator<B> mapI(IterableIterator<A> i, IF1<A, B> f) {
    return mapI((Iterator<A>) i, f);
  }

  static public <A, B> IterableIterator<B> mapI(IF1<A, B> f, Iterable<A> i) {
    return mapI(i, (Object) f);
  }

  static public IterableIterator mapI(Iterable i, Object f) {
    return mapI(f, i.iterator());
  }

  static public IterableIterator mapI(Object f, Iterable i) {
    return mapI(i, f);
  }

  static public void setMeta(IMeta o, Object key, Object value) {
    metaMapPut(o, key, value);
  }

  static public void setMeta(Object o, Object key, Object value) {
    metaMapPut(o, key, value);
  }

  static public <A extends Component> A repaint(A c) {
    if (c != null)
      c.repaint();
    return c;
  }

  static public void imageSurface_unpixelated(ImageSurface imageSurface) {
    if (imageSurface == null)
      return;
    imageSurface.interpolationMode = RenderingHints.VALUE_INTERPOLATION_BILINEAR;
    repaint(imageSurface);
  }

  static public BufferedImage copyImage(Image img) {
    if (img == null)
      return null;
    if (img instanceof BufferedImage)
      return copyImage((BufferedImage) img);
    int w = img.getWidth(null), h = img.getHeight(null);
    BufferedImage bi = newBufferedImage(w, h);
    drawImage(bi, img);
    return bi;
  }

  static public BufferedImage copyImage(BufferedImage bi) {
    if (bi == null)
      return null;
    ColorModel cm = bi.getColorModel();
    boolean isAlphaPremultiplied = cm.isAlphaPremultiplied();
    WritableRaster raster = bi.copyData(bi.getRaster().createCompatibleWritableRaster());
    return new BufferedImage(cm, raster, isAlphaPremultiplied, null);
  }

  static public String[] asStringArray(Collection<String> c) {
    return toStringArray(c);
  }

  static public String[] asStringArray(Object o) {
    return toStringArray(o);
  }

  static public String rtrim_fromLines(Collection lines) {
    StringBuilder buf = new StringBuilder();
    if (lines != null) {
      boolean first = true;
      for (Object line : lines) {
        if (first)
          first = false;
        else
          buf.append('\n');
        buf.append(str(line));
      }
    }
    return buf.toString();
  }

  static public BufferedImage cloneBufferedImageWithMeta(BufferedImage img) {
    if (img == null)
      return null;
    if (toIMeta(img) != null)
      return img;
    Hashtable<String, Object> properties = new Hashtable();
    var names = img.getPropertyNames();
    if (names != null)
      for (var key : names) properties.put(key, img.getProperty(key));
    if (!properties.containsKey("meta"))
      properties.put("meta", new Meta());
    var cm = img.getColorModel();
    var img2 = new BufferedImage(cm, img.getRaster(), cm.hasAlpha() && cm.isAlphaPremultiplied(), properties);
    assertNotNull(toIMeta(img2));
    return img2;
  }

  static public JMenuItem directJMenuItem(Action a) {
    return new JMenuItem(a) {

      public Dimension getMaximumSize() {
        return new Dimension(super.getPreferredSize().width, super.getMaximumSize().height);
      }
    };
  }

  static public JMenuItem directJMenuItem(String text, Object action) {
    return directJMenuItem(abstractAction(text, action));
  }

  static public JMenuBar addMenuBar(final Component c) {
    return swing(new F0<JMenuBar>() {

      public JMenuBar get() {
        try {
          RootPaneContainer f = getPossiblyInternalFrame(c);
          if (f == null)
            return null;
          JMenuBar bar = (JMenuBar) (call(f, "getJMenuBar"));
          if (bar == null) {
            setMenuBar(f, bar = new JMenuBar());
            revalidate((Component) f);
          }
          return bar;
        } catch (Exception __e) {
          throw rethrow(__e);
        }
      }

      public String toString() {
        return "RootPaneContainer f = getPossiblyInternalFrame(c);\r\n    if (f == null) null;\r...";
      }
    });
  }

  static public String renderVars_str(Object... params) {
    List<String> l = new ArrayList();
    int i = 0;
    if (odd(l(params))) {
      l.add(strOrNull(first(params)));
      ++i;
    }
    for (; i + 1 < l(params); i += 2) l.add(params[i] + "=" + params[i + 1]);
    return trim(joinWithComma(l));
  }

  static public <A extends DynamicObject> A setDyn(A o, String key, Object value) {
    setDynObjectValue(o, key, value);
    return o;
  }

  static public void setDyn(IMeta o, String key, Object value) {
    metaMapPut(o, key, value);
  }

  static public <A, B> B getOrCreate(Map<A, B> map, A key, Class<? extends B> c) {
    try {
      B b = map.get(key);
      if (b == null)
        map.put(key, b = c.newInstance());
      return b;
    } catch (Exception __e) {
      throw rethrow(__e);
    }
  }

  static public <A, B> B getOrCreate(Map<A, B> map, A key, Object f) {
    try {
      B b = map.get(key);
      if (b == null)
        map.put(key, b = (B) callF(f));
      return b;
    } catch (Exception __e) {
      throw rethrow(__e);
    }
  }

  static public <A, B> B getOrCreate(IF0<B> f, Map<A, B> map, A key) {
    return getOrCreate(map, key, f);
  }

  static public <A, B> B getOrCreate(Map<A, B> map, A key, IF0<B> f) {
    B b = map.get(key);
    if (b == null)
      map.put(key, b = f.get());
    return b;
  }

  static public <A, B> B getOrCreate(Class<? extends B> c, Map<A, B> map, A key) {
    return getOrCreate(map, key, c);
  }

  static public JRootPane getRootPane(Component c) {
    Component f = (Component) getPossiblyInternalFrame(c);
    return f instanceof RootPaneContainer ? (JRootPane) swingCall(f, "getRootPane") : null;
  }

  static public void caretToHome(JTextComponent c) {
    setCaret(c, 0);
  }

  static public void printStackTrace_inPossiblyCancelledThread(Throwable e) {
    AutoCloseable __1 = tempUncancelThread();
    try {
      System.out.println(getStackTrace_noRecord(e));
    } finally {
      _close(__1);
    }
  }

  static public List beforeDelegatingToThread_operations = synchroList();

  static public void beforeDelegatingToThread(Thread t) {
    for (Object op : cloneList(beforeDelegatingToThread_operations)) pcallF(op, t);
  }

  static public void beforeDelegatingToThread_do(Object f) {
    setAdd(beforeDelegatingToThread_operations, f);
  }

  static public <A, B> Either<A, B> either2(B b) {
    return new Either(2, b);
  }

  static public <A, B> Either<A, B> either1(A a) {
    return new Either(1, a);
  }

  static public List afterDelegatingToThread_operations = synchroList();

  static public void afterDelegatingToThread(Thread t) {
    for (Object op : cloneList(afterDelegatingToThread_operations)) pcallF(op, t);
  }

  static public void afterDelegatingToThread_do(Object f) {
    setAdd(afterDelegatingToThread_operations, f);
  }

  static public <B> TreeMap<String, B> asCaseInsensitiveMap(Map<String, B> map) {
    if (isCIMap(map))
      return (TreeMap) map;
    TreeMap<String, B> m = ciMap();
    putAll(m, map);
    return m;
  }

  static public List<String> nlTok(String s) {
    return javaTokPlusPeriod(s);
  }

  static public void logMechListAppendLocally(String listName, String text) {
    if (empty(text))
      return;
    logStructureWithDate(mechListAppendLogFile(listName), litorderedmap("list", listName, "text", text));
    appendToFile(createLocalMechListFile(listName), assureTrailingNewLine(text));
  }

  static public JButton jImageAndTextButton_defaultPlacement(String imageID, String text, Object action) {
    return setText(jImageButton(imageID, action), text);
  }

  static public JButton jImageAndTextButton_defaultPlacement(String imageID, String text) {
    return jImageAndTextButton_defaultPlacement(imageID, text, null);
  }

  static public BufferedImage imageToBufferedImage(Image img) {
    if (img == null || img instanceof BufferedImage)
      return (BufferedImage) img;
    BufferedImage bimage = new BufferedImage(img.getWidth(null), img.getHeight(null), BufferedImage.TYPE_INT_ARGB);
    bimage.createGraphics().drawImage(img, 0, 0, null);
    return bimage;
  }

  static public BufferedImage scaleBufferedImageToMaxWidthOrHeight(int max, BufferedImage img) {
    int w = img.getWidth(), h = img.getHeight();
    if (w <= max && h <= max)
      return img;
    double scale = max / (double) max(w, h);
    return scaleImage(img, scale);
  }

  static public BufferedImage scaleBufferedImageToMaxWidthOrHeight(BufferedImage img, int max) {
    return scaleBufferedImageToMaxWidthOrHeight(max, img);
  }

  static public void appendToMechQ_withDate(final String listName, final String text) {
    mechAppend_noUniq_inQ(listName, "[" + localDateWithMilliseconds() + "] " + text);
  }

  static public int packFrame_minw = 150, packFrame_minh = 50;

  static public <A extends Component> A packFrame(final A c) {
    {
      swing(() -> {
        Window w = getWindow(c);
        if (w != null) {
          w.pack();
          int maxW = getScreenWidth() - 50, maxH = getScreenHeight() - 50;
          w.setSize(min(maxW, max(w.getWidth(), packFrame_minw)), min(maxH, max(w.getHeight(), packFrame_minh)));
        }
      });
    }
    return c;
  }

  static public JFrame packFrame(ButtonGroup g) {
    return packFrame(getFrame(g));
  }

  static public JFrame showFrame() {
    return makeFrame();
  }

  static public JFrame showFrame(Object content) {
    return makeFrame(content);
  }

  static public JFrame showFrame(String title) {
    return makeFrame(title);
  }

  static public JFrame showFrame(String title, Object content) {
    return makeFrame(title, content);
  }

  static public JFrame showFrame(final JFrame f) {
    if (f != null) {
      swing(() -> {
        if (frameTooSmall(f))
          frameStandardSize(f);
        if (!f.isVisible())
          f.setVisible(true);
        if (f.getState() == Frame.ICONIFIED)
          f.setState(Frame.NORMAL);
      });
    }
    return f;
  }

  static public JFrame showFrame(String title, Object content, JFrame frame) {
    if (frame == null)
      return showFrame(title, content);
    else {
      frame.setTitle(title);
      setFrameContents(frame, content);
      return frame;
    }
  }

  static public void tableDependButtons(final JTable table, List<? extends Component> buttons) {
    for (Component c : buttons) if (c instanceof JButton) {
      final JButton b = (JButton) c;
      table.getSelectionModel().addListSelectionListener(new ListSelectionListener() {

        public void valueChanged(ListSelectionEvent e) {
          b.setEnabled(table.getSelectedRow() >= 0);
        }
      });
      b.setEnabled(table.getSelectedRow() >= 0);
    }
  }

  static public JTextField standardTextFieldPopupMenu(final JTextField tf) {
    final WeakReference<JTextField> ref = weakRef(tf);
    componentPopupMenuItem(tf, "Copy text to clipboard", new Runnable() {

      public void run() {
        try {
          copyTextToClipboard(ref.get().getText());
        } catch (Exception __e) {
          throw rethrow(__e);
        }
      }

      public String toString() {
        return "copyTextToClipboard(ref.get().getText())";
      }
    });
    componentPopupMenuItem(tf, "Paste", new Runnable() {

      public void run() {
        try {
          ref.get().paste();
        } catch (Exception __e) {
          throw rethrow(__e);
        }
      }

      public String toString() {
        return "ref.get().paste()";
      }
    });
    return tf;
  }

  static public File tempFileFor(File f) {
    return new File(f.getPath() + "_temp");
  }

  static public List<Character> stringAsCharacterList(final String s) {
    if (s == null)
      return null;
    return new RandomAccessAbstractList<Character>() {

      final public int l = l(s);

      public int size() {
        return l;
      }

      public Character get(int i) {
        return s.charAt(i);
      }
    };
  }

  static public boolean isSubclassOf(Class a, Class b) {
    return isSubclass(a, b);
  }

  static public int lCommonPrefix(String a, String b) {
    int i = 0, n = Math.min(l(a), l(b));
    while (i < n && a.charAt(i) == b.charAt(i)) ++i;
    return i;
  }

  static public JLabel jcenteredBoldLabel(String text) {
    JLabel l = jboldLabel(text);
    l.setHorizontalAlignment(JLabel.CENTER);
    return l;
  }

  static public JLabel jcenteredBoldLabel() {
    return jcenteredBoldLabel("");
  }

  static public <A> AutoCloseable tempSetTL(ThreadLocal<A> tl, A a) {
    return tempSetThreadLocal(tl, a);
  }

  static public <A> AutoCloseable tempSetTL(BetterThreadLocal<A> tl, A a) {
    return tempSetThreadLocalIfNecessary(tl, a);
  }

  static public BufferedImage createBufferedImage(int w, int h, Color color) {
    return newBufferedImage(w, h, color);
  }

  static public JLabel jimage(Image img) {
    return jImageLabel(img);
  }

  static public JLabel jimage(String imageID) {
    return jImageLabel(imageID);
  }

  static public BufferedImage scaleImage_bilinear(BufferedImage before, double scaleX) {
    return scaleImage_bilinear(before, scaleX, scaleX);
  }

  static public BufferedImage scaleImage_bilinear(BufferedImage before, double scaleX, double scaleY) {
    return scaleImageWithOp(before, scaleX, scaleY, AffineTransformOp.TYPE_BILINEAR);
  }

  static public BufferedImage scaleImage_bilinear(double scale, BufferedImage before) {
    return scaleImage_bilinear(before, scale);
  }

  static public String lines_possiblyRTrim(String originalText, List<String> lines) {
    return endsWithNewLine(originalText) ? lines(lines) : lines_rtrim(lines);
  }

  static public String lines_possiblyRTrim(List<String> lines, String originalText) {
    return lines_possiblyRTrim(originalText, lines);
  }

  static public <B> List<B> mapLines(String text, F1<String, B> f) {
    return mapLines(f, text);
  }

  static public <B> List<B> mapLines(F1<String, B> f, String text) {
    return mapLines(f1ToIF1(f), text);
  }

  static public <B> List<B> mapLines(String text, IF1<String, B> f) {
    return mapLines(f, text);
  }

  static public <B> List<B> mapLines(IF1<String, B> f, String text) {
    return map(f, lines(text));
  }

  static public List<String> regexpGetGroups(Matcher matcher) {
    int n = matcher.groupCount();
    List<String> l = new ArrayList();
    for (int i = 1; i <= n; i++) l.add(matcher.group(i));
    return l;
  }

  static public List<String> regexpGetGroups(String pat, String s) {
    Matcher m = regexpMatcher(pat, s);
    if (m.find())
      return regexpGetGroups(m);
    return null;
  }

  static public IntRange intRangeWithLen(int start, int len) {
    return new IntRange(start, start + len);
  }

  static public String spaces(int n) {
    return rep(' ', n);
  }

  static public void sortIntRangesInPlace(List<IntRange> l) {
    sortInPlaceByCalculatedField(l, r -> r.start);
  }

  static public <A> List<A> sortByCalculatedField(Iterable<A> c, final Object f) {
    List<A> l = cloneList(c);
    sort(l, new Comparator<A>() {

      public int compare(A a, A b) {
        return stdcompare(callF(f, a), callF(f, b));
      }
    });
    return l;
  }

  static public String reverseString(String s) {
    return empty(s) ? s : new StringBuilder(s).reverse().toString();
  }

  static public boolean rectsOverlap(Rect a, Rect b) {
    return !intersectRects(a, b).empty();
  }

  static public BufferedImage scaleImage(BufferedImage before, double scaleX) {
    return scaleImage(before, scaleX, scaleX);
  }

  static public BufferedImage scaleImage(BufferedImage before, double scaleX, double scaleY) {
    return scaleImageWithOp(before, scaleX, scaleY, AffineTransformOp.TYPE_BILINEAR);
  }

  static public BufferedImage scaleImage(double scale, BufferedImage before) {
    return scaleImage(before, scale);
  }

  static public boolean zipFileContains_falseOnError(File inZip, String fileName) {
    try {
      return zipFileContains(inZip, fileName);
    } catch (Throwable e) {
      return false;
    }
  }

  static public File javaHome() {
    return envJavaHome();
  }

  static public File javaHome(String sub) {
    return newFile(envJavaHome(), sub);
  }

  static public File jigsawModuleFile(String moduleName) {
    return jigsawModuleFile(moduleName, javaHome());
  }

  static public File jigsawModuleFile(String moduleName, File javaHome) {
    return new File(javaHome, "jmods/" + moduleName + ".jmod");
  }

  static public Graphics2D antiAliasGraphics(BufferedImage img) {
    return antiAliasOn(createGraphics(img));
  }

  static public <A, B> List<B> lambdaMap(IF1<A, B> f, Iterable<A> l) {
    return map(l, f);
  }

  static public <A, B> List<B> lambdaMap(IF1<A, B> f, A[] l) {
    return map(l, f);
  }

  static public <A> A getVar(IF0<A> v) {
    return v == null ? null : v.get();
  }

  static public <A> A getVar(Optional<A> v) {
    return v == null ? null : v.orElse(null);
  }

  static public <A> List<A> listMinusSet(Iterable<A> l, Collection<? extends A> stuff) {
    if (l == null)
      return null;
    if (empty(stuff))
      return asList(l);
    Set<? extends A> set = asSet(stuff);
    List<A> l2 = new ArrayList();
    for (A a : l) if (!set.contains(a))
      l2.add(a);
    return l2;
  }

  static public <A> List<A> listMinusSet(Iterable<A> l, Collection<A> stuff, Collection<? extends A> stuff2) {
    return listMinusSet(listMinusSet(l, stuff), stuff2);
  }

  static public String toStringOpt(Object o) {
    return o instanceof String ? ((String) o) : null;
  }

  static public <A> TreeSet<A> asTreeSet(Collection<A> set) {
    return set == null ? null : set instanceof TreeSet ? (TreeSet) set : new TreeSet(set);
  }

  static public Set<String> allNonStaticFields(Object o) {
    TreeSet<String> fields = new TreeSet();
    Class _c = _getClass(o);
    do {
      for (Field f : _c.getDeclaredFields()) if ((f.getModifiers() & Modifier.STATIC) == 0)
        fields.add(f.getName());
      _c = _c.getSuperclass();
    } while (_c != null);
    return fields;
  }

  static public <A> void setAddAll(Collection<A> a, Collection<A> b) {
    for (A x : b) setAdd(a, x);
  }

  static public ThreadLocal<Boolean> dataToTable_useStruct = threadLocalWithDefault(true);

  static public void dataToTable_dynSet(List l, int i, Object s) {
    while (i >= l.size()) l.add("");
    l.set(i, s);
  }

  static public List dataToTable_makeRow(Object x, List<String> cols) {
    if (instanceOf(x, "DynamicObject"))
      x = get_raw(x, "fieldValues");
    if (x instanceof Map) {
      Map m = (Map) x;
      List row = new ArrayList();
      for (Object _field : keysWithoutHidden(m)) {
        String field = (String) _field;
        Object value = m.get(field);
        int col = cols.indexOf(field);
        if (col < 0) {
          cols.add(field);
          col = cols.size() - 1;
        }
        dataToTable_dynSet(row, col, dataToTable_wrapValue(value));
      }
      return row;
    }
    if (x instanceof List)
      return allToString((List) x);
    return litlist(structureOrText(x));
  }

  static public Object dataToTable_wrapValue(Object o) {
    if (o instanceof BufferedImage)
      return o;
    if (o instanceof MakesBufferedImage)
      return ((MakesBufferedImage) o).getBufferedImage();
    if (o instanceof RGBImage)
      return o;
    if (o instanceof Boolean)
      return o;
    return dataToTable_useStruct.get() ? structureOrTextForUser(o) : strOrNull(o);
  }

  static public <A> ArrayList<A> litlist(A... a) {
    ArrayList l = new ArrayList(a.length);
    for (A x : a) l.add(x);
    return l;
  }

  static public String structureOrTextForUser(Object o) {
    return o == null ? "" : o instanceof String ? (String) o : structureForUser(o);
  }

  static public void fillTableWithData(final JTable table, List<List> rows, List<String> colNames) {
    fillTableWithData(table, rows, toStringArray(colNames));
  }

  static public void fillTableWithData(final JTable table, List<List> rows, String... colNames) {
    final DefaultTableModel model = fillTableWithData_makeModel(rows, colNames);
    setTableModel(table, model);
  }

  static public DefaultTableModel fillTableWithData_makeModel(List<List> rows, String... colNames) {
    Pair<Object[][], Object[]> p = fillTableWithData_makeData(rows, colNames);
    return new DefaultTableModel(p.a, p.b) {

      public Class getColumnClass(int column) {
        return or(_getClass(getValueAt(0, column)), String.class);
      }

      public boolean isCellEditable(int rowIndex, int columnIndex) {
        return false;
      }
    };
  }

  static public void fillTableWithStrings(final JTable table, List<List<String>> rows, List<String> colNames) {
    fillTableWithStrings(table, rows, toStringArray(colNames));
  }

  static public void fillTableWithStrings(final JTable table, List<List<String>> rows, String... colNames) {
    final DefaultTableModel model = fillTableWithStrings_makeModel(rows, colNames);
    swingNowOrLater(new Runnable() {

      public void run() {
        try {
          setTableModel(table, model);
        } catch (Exception __e) {
          throw rethrow(__e);
        }
      }

      public String toString() {
        return "setTableModel(table, model);";
      }
    });
  }

  static public DefaultTableModel fillTableWithStrings_makeModel(List<List<String>> rows, String... colNames) {
    Object[][] data = new Object[rows.size()][];
    int w = 0;
    for (int i = 0; i < rows.size(); i++) {
      List<String> l = rows.get(i);
      Object[] r = new Object[l.size()];
      for (int j = 0; j < l.size(); j++) r[j] = l.get(j);
      data[i] = r;
      w = Math.max(w, l.size());
    }
    Object[] columnNames = new Object[w];
    for (int i = 0; i < w; i++) columnNames[i] = i < l(colNames) ? colNames[i] : "?";
    return new DefaultTableModel(data, columnNames);
  }

  static public Object selectedTableCell(JTable t, int col) {
    return getTableCell(t, selectedTableRow(t), col);
  }

  static public Object selectedTableCell(final JTable t) {
    return swing(new F0<Object>() {

      public Object get() {
        try {
          return selectedTableCell(t, t.getSelectedColumn());
        } catch (Exception __e) {
          throw rethrow(__e);
        }
      }

      public String toString() {
        return "return selectedTableCell(t, t.getSelectedColumn());";
      }
    });
  }

  static public Object selectedTableCell(final JTable t, final String colName) {
    return swing(new F0<Object>() {

      public Object get() {
        try {
          return selectedTableCell(t, tableColumnViewIndex(t, colName));
        } catch (Exception __e) {
          throw rethrow(__e);
        }
      }

      public String toString() {
        return "return selectedTableCell(t, tableColumnViewIndex(t, colName));";
      }
    });
  }

  static public void tableEnableDrag(final JTable table, TransferHandler th) {
    if (table.getDragEnabled()) {
      print("Table drag already enabled");
      return;
    }
    table.setDragEnabled(true);
    table.setTransferHandler(th);
    table.addMouseListener(new MouseAdapter() {

      @Override
      public void mousePressed(MouseEvent e) {
        if (e.getButton() == 1 && e.getClickCount() == 1)
          table.getTransferHandler().exportAsDrag(table, e, TransferHandler.COPY);
      }
    });
  }

  static public String getTextTrim(JTextComponent c) {
    return trim(getText(c));
  }

  static public String getTextTrim(JComboBox cb) {
    return trim(getText(cb));
  }

  static public String getTextTrim(JComponent c) {
    if (c instanceof JLabel)
      return trim(((JLabel) c).getText());
    if (c instanceof JComboBox)
      return getTextTrim((JComboBox) c);
    return getTextTrim((JTextComponent) c);
  }

  static public boolean containsIgnoreCase(Collection<String> l, String s) {
    if (l != null)
      for (String x : l) if (eqic(x, s))
        return true;
    return false;
  }

  static public boolean containsIgnoreCase(String[] l, String s) {
    if (l != null)
      for (String x : l) if (eqic(x, s))
        return true;
    return false;
  }

  static public boolean containsIgnoreCase(String s, char c) {
    return indexOfIgnoreCase(s, String.valueOf(c)) >= 0;
  }

  static public boolean containsIgnoreCase(String a, String b) {
    return indexOfIgnoreCase(a, b) >= 0;
  }

  static public Map<String, Object> rawTableLineAsMap(JTable tbl, int row) {
    if (row >= 0 && row < tbl.getModel().getRowCount()) {
      Map<String, Object> map = litorderedmap();
      for (int i = 0; i < tbl.getModel().getColumnCount(); i++) mapPut(map, tbl.getModel().getColumnName(i), tbl.getModel().getValueAt(row, i));
      return map;
    }
    return null;
  }

  static public <A> List<A> wrapAsList(A[] a) {
    return wrapArrayAsList(a);
  }

  static public void assertNotOnAWTThread() {
    assertFalse("Can't do this in AWT thread", isAWTThread());
  }

  static public void onFrameClose(Component c, final Runnable r) {
    JFrame f = getFrame(c);
    if (f != null)
      f.addWindowListener(new WindowAdapter() {

        public void windowClosing(WindowEvent e) {
          try {
            r.run();
          } catch (Throwable __e) {
            messageBox(__e);
          }
        }
      });
  }

  static public Object[] arrayPlus(Object[] a1, Object... a2) {
    return concatArrays(a1, a2);
  }

  static public <A> A waitUntilVarSet(Var<A> v) {
    try {
      synchronized (v) {
        while (!v.has()) v.wait();
        return v.get();
      }
    } catch (Exception __e) {
      throw rethrow(__e);
    }
  }

  static public <A> A waitUntilVarSet(Var<A> v, int timeout) {
    try {
      synchronized (v) {
        long time = nanoTime();
        while (!v.has() && (nanoTime() - time) < timeout * 900000) v.wait(timeout);
        return v.get();
      }
    } catch (Exception __e) {
      throw rethrow(__e);
    }
  }

  static public String indentStructureString(String s) {
    return indentStructureString(100, s);
  }

  static public String indentStructureString(int levels, String s) {
    if (s == null)
      return null;
    List<String> tok = javaTokForStructure(s);
    StringBuilder buf = new StringBuilder();
    int indent = 0;
    levels = clampToInt(levels * 2L);
    for (int i = 0; i < l(tok); i++) {
      String t = tok.get(i);
      if (isOpeningBracket(t)) {
        int j = i + 5;
        if (containsClosingBracket(subList(tok, i + 2, i + 5))) {
          buf.append(joinSubList(tok, i, j));
          i = j - 1;
        } else {
          indent += 2;
          buf.append(t);
          if (indent <= levels)
            buf.append("\n").append(spaces(indent));
        }
      } else if (isClosingBracket(t)) {
        indent -= 2;
        if (indent < levels)
          buf.append("\n").append(spaces(indent));
        buf.append(t);
      } else if (indent <= levels && eq(t, ",")) {
        buf.append(t).append("\n").append(spaces(indent));
        i++;
      } else
        buf.append(t);
    }
    return str(buf);
  }

  static public String structForUser(Object o) {
    return structureForUser(o);
  }

  static public byte[] scaledGrayBytesFromBWIntegralImage(int w, BWIntegralImage img) {
    return scaledGrayBytesFromBWIntegralImage(img, w);
  }

  static public byte[] scaledGrayBytesFromBWIntegralImage(BWIntegralImage img, int w) {
    return scaledGrayBytesFromBWIntegralImage(img, w, heightForWidth(img, w));
  }

  static public byte[] scaledGrayBytesFromBWIntegralImage(BWIntegralImage img, int w, int h) {
    int w1 = img.getWidth(), h1 = img.getHeight();
    double stepX = doubleRatio(w1, w), stepY = doubleRatio(h1, h);
    byte[] pixels = new byte[w * h];
    int i = 0;
    double srcY = 0;
    for (int y = 0; y < h; y++) {
      double srcX = 0, nextSrcY = srcY + stepY;
      for (int x = 0; x < w; x++) {
        double nextSrcX = srcX + stepX;
        int pixel = iround(img.getPixelAverage(srcX, srcY, nextSrcX, nextSrcY));
        pixels[i++] = clampToUByte(pixel);
        srcX = nextSrcX;
      }
      srcY = nextSrcY;
    }
    return pixels;
  }

  static public byte[] scaledGrayBytesFromBWIntegralImage(int w, IBWIntegralImage img) {
    return scaledGrayBytesFromBWIntegralImage(img, w);
  }

  static public byte[] scaledGrayBytesFromBWIntegralImage(IBWIntegralImage img, int w) {
    return scaledGrayBytesFromBWIntegralImage(img, w, heightForWidth(img, w));
  }

  static public byte[] scaledGrayBytesFromBWIntegralImage(IBWIntegralImage img, int w, int h) {
    int w1 = img.getWidth(), h1 = img.getHeight();
    double stepX = doubleRatio(w1, w), stepY = doubleRatio(h1, h);
    byte[] pixels = new byte[w * h];
    int i = 0;
    double srcY = 0;
    for (int y = 0; y < h; y++) {
      double srcX = 0, nextSrcY = srcY + stepY;
      for (int x = 0; x < w; x++) {
        double nextSrcX = srcX + stepX;
        int pixel = iround(img.getPixelAverage(srcX, srcY, nextSrcX, nextSrcY));
        pixels[i++] = clampToUByte(pixel);
        srcX = nextSrcX;
      }
      srcY = nextSrcY;
    }
    return pixels;
  }

  static public TreeMap revTreeMap() {
    return new TreeMap(reverseComparator());
  }

  static public int indexOfIC_underscore(String a, String b) {
    int la = l(a), lb = l(b);
    if (la < lb)
      return -1;
    int n = la - lb;
    elsewhere: for (int i = 0; i <= n; i++) {
      for (int j = 0; j < lb; j++) {
        char c2 = b.charAt(j);
        if (c2 == '_' || eqic(c2, a.charAt(i + j))) {
        } else
          continue elsewhere;
      }
      return i;
    }
    return -1;
  }

  static public <A, B> B secondOfPair(Pair<A, B> p) {
    return p == null ? null : p.b;
  }

  static public BufferedImage drawImage(BufferedImage canvas, Image img, Pt p) {
    return drawImageOnImage(img, canvas, p.x, p.y);
  }

  static public void drawImage(BufferedImage g, Image img) {
    drawImage(graphics(g), img);
  }

  static public void drawImage(Graphics2D g, Image img) {
    drawImage(g, img, 0, 0);
  }

  static public void drawImage(Graphics2D g, Image img, Pt p) {
    drawImage(g, img, p.x, p.y);
  }

  static public void drawImage(Graphics2D g, Image img, int x, int y) {
    {
      if (g != null)
        g.drawImage(img, x, y, null);
    }
  }

  static public IMeta toIMeta(Object o) {
    if (o == null)
      return null;
    if (o instanceof IMeta)
      return ((IMeta) o);
    if (o instanceof JComponent)
      return initMetaOfJComponent((JComponent) o);
    if (o instanceof BufferedImage)
      return optCast(IMeta.class, ((BufferedImage) o).getProperty("meta"));
    return null;
  }

  static public RootPaneContainer getPossiblyInternalFrame(Component c) {
    JInternalFrame f = getInternalFrame(c);
    if (f != null)
      return f;
    return optCast(RootPaneContainer.class, getWindow(c));
  }

  static public void setMenuBar(final JMenuBar mb, final RootPaneContainer f) {
    {
      swing(() -> {
        call(f, "setJMenuBar", mb);
        revalidate((Component) f);
      });
    }
  }

  static public void setMenuBar(RootPaneContainer f, JMenuBar mb) {
    setMenuBar(mb, f);
  }

  static public void setDynObjectValue(DynamicObject o, String field, Object value) {
    dynamicObject_setRawFieldValue(o, field, value);
  }

  static public void setCaret(final JTextComponent c, final int pos) {
    if (c != null) {
      swing(() -> {
        c.setCaretPosition(pos);
      });
    }
  }

  static public AutoCloseable tempUncancelThread() {
    return tempRemove(ping_actions, Thread.currentThread());
  }

  static public boolean isCIMap(Map m) {
    return m instanceof TreeMap && ((TreeMap) m).comparator() == caseInsensitiveComparator();
  }

  static public <A> TreeMap<String, A> ciMap() {
    return caseInsensitiveMap();
  }

  static public List<String> javaTokPlusPeriod(String s) {
    List<String> tok = new ArrayList<String>();
    if (s == null)
      return tok;
    int l = s.length();
    int i = 0;
    while (i < l) {
      int j = i;
      char c;
      String cc;
      while (j < l) {
        c = s.charAt(j);
        cc = s.substring(j, Math.min(j + 2, l));
        if (c == ' ' || c == '\t' || c == '\r' || c == '\n')
          ++j;
        else if (cc.equals("/*")) {
          do ++j; while (j < l && !s.substring(j, Math.min(j + 2, l)).equals("*/"));
          j = Math.min(j + 2, l);
        } else if (cc.equals("//")) {
          do ++j; while (j < l && "\r\n".indexOf(s.charAt(j)) < 0);
        } else
          break;
      }
      tok.add(s.substring(i, j));
      i = j;
      if (i >= l)
        break;
      c = s.charAt(i);
      cc = s.substring(i, Math.min(i + 2, l));
      if (c == (char) 0x201C || c == (char) 0x201D)
        c = '"';
      if (c == '\'' || c == '"') {
        char opener = c;
        ++j;
        while (j < l) {
          char _c = s.charAt(j);
          if (_c == (char) 0x201C || _c == (char) 0x201D)
            _c = '"';
          if (_c == opener) {
            ++j;
            break;
          } else if (s.charAt(j) == '\\' && j + 1 < l)
            j += 2;
          else
            ++j;
        }
        if (j - 1 >= i + 1) {
          tok.add(opener + s.substring(i + 1, j - 1) + opener);
          i = j;
          continue;
        }
      } else if (Character.isJavaIdentifierStart(c))
        do ++j; while (j < l && (Character.isJavaIdentifierPart(s.charAt(j)) || s.charAt(j) == '\''));
      else if (Character.isDigit(c))
        do ++j; while (j < l && Character.isDigit(s.charAt(j)));
      else if (cc.equals("[[")) {
        do ++j; while (j + 1 < l && !s.substring(j, j + 2).equals("]]"));
        j = Math.min(j + 2, l);
      } else if (cc.equals("[=") && i + 2 < l && s.charAt(i + 2) == '[') {
        do ++j; while (j + 2 < l && !s.substring(j, j + 3).equals("]=]"));
        j = Math.min(j + 3, l);
      } else if (s.substring(j, Math.min(j + 3, l)).equals("..."))
        j += 3;
      else if (c == '$' || c == '#')
        do ++j; while (j < l && Character.isDigit(s.charAt(j)));
      else
        ++j;
      tok.add(s.substring(i, j));
      i = j;
    }
    if ((tok.size() % 2) == 0)
      tok.add("");
    return tok;
  }

  static public <A> A logStructureWithDate(File logFile, A o) {
    logQuoted(logFile, now() + " " + structure(o));
    return o;
  }

  static public <A> A logStructureWithDate(String fileName, A o) {
    return logStructureWithDate(getProgramFile(fileName), o);
  }

  static public File mechListAppendLogFile(String listName) {
    return javaxDataDir("Mech List Appends/" + uniqueFileNameUsingMD5_80(listName));
  }

  static public File createLocalMechListFile(String listName) {
    File nameFile = localMechListNameFile(listName);
    if (!nameFile.exists())
      saveTextFile(nameFile, listName);
    return localMechListFile(listName);
  }

  static public String assureTrailingNewLine(String s) {
    return addSuffix(s, "\n");
  }

  static public JButton jImageButton(String imageID, Object action) {
    return jimageButton(imageID, action);
  }

  static public JButton jImageButton(String imageID) {
    return jimageButton(imageID);
  }

  static public void mechAppend_noUniq_inQ(final String listName, final String text) {
    appendToMechList_noUniq_inQ(listName, text);
  }

  static public String localDateWithMilliseconds(Date time) {
    return localDateWithMilliseconds(time.getTime());
  }

  static public String localDateWithMilliseconds(long time) {
    SimpleDateFormat format = simpleDateFormat_local("yyyy/MM/dd HH:mm:ss''SSSS");
    return format.format(time);
  }

  static public String localDateWithMilliseconds() {
    return localDateWithMilliseconds(now());
  }

  static public boolean frameTooSmall(JFrame frame) {
    return frame.getWidth() < 100 || frame.getHeight() < 50;
  }

  static public void frameStandardSize(JFrame frame) {
    frame.setBounds(300, 100, 500, 400);
  }

  static public void setFrameContents(final Component c, final Object contents) {
    swing(() -> {
      JFrame frame = getFrame(c);
      if (frame == null)
        return;
      frame.getContentPane().removeAll();
      frame.getContentPane().setLayout(new BorderLayout());
      frame.getContentPane().add(wrap(contents));
      revalidate(frame);
    });
  }

  static public boolean isSubclass(Class a, Class b) {
    return a != null && b != null && b.isAssignableFrom(a);
  }

  static public JLabel jboldLabel(String text) {
    return makeLabelBold(jlabel(text));
  }

  static public <A> AutoCloseable tempSetThreadLocal(final ThreadLocal<A> tl, A a) {
    if (tl == null)
      return null;
    final A prev = setThreadLocal(tl, a);
    return new AutoCloseable() {

      public String toString() {
        return "tl.set(prev);";
      }

      public void close() throws Exception {
        tl.set(prev);
      }
    };
  }

  static public <A> AutoCloseable tempSetThreadLocalIfNecessary(ThreadLocal<A> tl, A a) {
    if (tl == null)
      return null;
    A prev = tl.get();
    if (eq(prev, a))
      return null;
    tl.set(a);
    return new AutoCloseable() {

      public String toString() {
        return "tl.set(prev);";
      }

      public void close() throws Exception {
        tl.set(prev);
      }
    };
  }

  static public <A> AutoCloseable tempSetThreadLocalIfNecessary(BetterThreadLocal<A> tl, A a) {
    if (tl == null)
      return null;
    A prev = tl.get();
    if (eq(prev, a))
      return null;
    tl.set(a);
    return new AutoCloseable() {

      public String toString() {
        return "tl.set(prev);";
      }

      public void close() throws Exception {
        tl.set(prev);
      }
    };
  }

  static public JLabel jImageLabel(Image img) {
    return swingNu(JLabel.class, imageIcon(img));
  }

  static public JLabel jImageLabel(javax.swing.Icon icon) {
    return swingNu(JLabel.class, icon);
  }

  static public JLabel jImageLabel(String imageID) {
    return jImageLabel(imageIcon(imageID));
  }

  static public JLabel jImageLabel(String text, String imageID) {
    final JLabel l = swingNu(JLabel.class, text, imageIcon(imageID), JLabel.CENTER);
    {
      swing(() -> {
        l.setVerticalTextPosition(SwingConstants.BOTTOM);
        l.setHorizontalTextPosition(SwingConstants.CENTER);
      });
    }
    return l;
  }

  static public <A, B> IF1<A, B> f1ToIF1(F1<A, B> f) {
    return f == null ? null : a -> f.get(a);
  }

  static public <A> List<A> sortInPlaceByCalculatedField(List<A> l, final F1<A, ?> f) {
    sort(l, new Comparator<A>() {

      public int compare(A a, A b) {
        return stdcompare(f.get(a), f.get(b));
      }
    });
    return l;
  }

  static public <A> List<A> sortInPlaceByCalculatedField(List<A> l, final IF1<A, ?> f) {
    sort(l, new Comparator<A>() {

      public int compare(A a, A b) {
        return stdcompare(f.get(a), f.get(b));
      }
    });
    return l;
  }

  static public boolean zipFileContains(File inZip, String fileName) {
    try {
      ZipFile zip = new ZipFile(inZip);
      try {
        return zipFileContains(zip, fileName);
      } finally {
        zip.close();
      }
    } catch (Exception __e) {
      throw rethrow(__e);
    }
  }

  static public boolean zipFileContains(ZipFile zip, String fileName) {
    try {
      return zip.getEntry(fileName) != null;
    } catch (Exception __e) {
      throw rethrow(__e);
    }
  }

  static public File envJavaHome() {
    return newFile(System.getProperty("java.home"));
  }

  static public Graphics2D antiAliasOn(Graphics2D g) {
    g.setRenderingHint(RenderingHints.KEY_TEXT_ANTIALIASING, RenderingHints.VALUE_TEXT_ANTIALIAS_ON);
    g.setRenderingHint(RenderingHints.KEY_ANTIALIASING, RenderingHints.VALUE_ANTIALIAS_ON);
    return g;
  }

  static public <A> ThreadLocal<A> threadLocalWithDefault(A defaultValue) {
    return new ThreadLocal<A>() {

      public A initialValue() {
        return defaultValue;
      }
    };
  }

  static public <A, B> List<A> keysWithoutHidden(Map<A, B> map) {
    return filter(keys(map), new F1<Object, Boolean>() {

      public Boolean get(Object o) {
        try {
          return !eq(o, "[hidden]") && !isStringStartingWith(o, "[hidden] ");
        } catch (Exception __e) {
          throw rethrow(__e);
        }
      }

      public String toString() {
        return "!eq(o, \"[hidden]\") && !isStringStartingWith(o, \"[hidden] \")";
      }
    });
  }

  static public String structureOrText(Object o) {
    return o instanceof String ? (String) o : structure(o);
  }

  static public Map<JTable, VF1<JTable>> setTableModel_after = weakHashMap();

  static public Map<JTable, VF2<JTable, RowSorter>> setTableModel_fixSorter = weakHashMap();

  static public void setTableModel(final JTable table, final TableModel model) {
    {
      swing(() -> {
        Map<String, Integer> widths = tableColumnWidthsByName(table);
        int[] i = table.getSelectedRows();
        TableRowSorter sorter = model.getColumnCount() == tableColumnCount(table) ? (TableRowSorter) table.getRowSorter() : null;
        List<? extends RowSorter.SortKey> sortKeys = sorter == null ? null : sorter.getSortKeys();
        table.setModel(model);
        int n = model.getRowCount();
        ListSelectionModel sel = table.getSelectionModel();
        for (int j = 0; j < i.length; j++) if (i[j] < n)
          sel.addSelectionInterval(i[j], i[j]);
        tableSetColumnPreferredWidths(table, widths);
        if (sorter != null) {
          sorter.setModel(model);
          callF(setTableModel_fixSorter.get(table), table, sorter);
          if (sortKeys != null)
            sorter.setSortKeys(sortKeys);
        }
        table.setRowSorter(sorter);
        callF(setTableModel_after.get(table), table);
      });
    }
  }

  static public Pair<Object[][], Object[]> fillTableWithData_makeData(List<List> rows, List<String> colNames) {
    return fillTableWithData_makeData(rows, asStringArray(colNames));
  }

  static public Pair<Object[][], Object[]> fillTableWithData_makeData(List<List> rows, String... colNames) {
    Object[][] data = new Object[rows.size()][];
    int w = 0;
    for (int i = 0; i < rows.size(); i++) {
      List l = rows.get(i);
      Object[] r = new Object[l.size()];
      for (int j = 0; j < l.size(); j++) {
        Object o = l.get(j);
        if (o instanceof BufferedImage)
          o = imageIcon((BufferedImage) o);
        if (o instanceof RGBImage)
          o = imageIcon((RGBImage) o);
        r[j] = o;
      }
      data[i] = r;
      w = Math.max(w, l.size());
    }
    Object[] columnNames = new Object[w];
    for (int i = 0; i < w; i++) columnNames[i] = i < l(colNames) ? colNames[i] : "?";
    return pair(data, columnNames);
  }

  static public void swingNowOrLater(Runnable r) {
    if (isAWTThread())
      r.run();
    else
      swingLater(r);
  }

  static public Object getTableCell(JTable tbl, int row, int col) {
    if (row >= 0 && row < tbl.getModel().getRowCount())
      return tbl.getModel().getValueAt(row, col);
    return null;
  }

  static public int tableColumnViewIndex(final JTable t, final String colName) {
    return swing(new F0<Integer>() {

      public Integer get() {
        try {
          return t.convertColumnIndexToView(t.getColumn(colName).getModelIndex());
        } catch (Exception __e) {
          throw rethrow(__e);
        }
      }

      public String toString() {
        return "return t.convertColumnIndexToView(t.getColumn(colName).getModelIndex());";
      }
    });
  }

  static public int indexOfIgnoreCase(List<String> a, String b) {
    return indexOfIgnoreCase(a, b, 0);
  }

  static public int indexOfIgnoreCase(List<String> a, String b, int i) {
    int n = a == null ? 0 : a.size();
    for (; i < n; i++) if (eqic(a.get(i), b))
      return i;
    return -1;
  }

  static public int indexOfIgnoreCase(String[] a, String b) {
    return indexOfIgnoreCase(a, b, 0);
  }

  static public int indexOfIgnoreCase(String[] a, String b, int i) {
    int n = a == null ? 0 : a.length;
    for (; i < n; i++) if (eqic(a[i], b))
      return i;
    return -1;
  }

  static public int indexOfIgnoreCase(String a, String b) {
    return indexOfIgnoreCase_manual(a, b);
  }

  static public int indexOfIgnoreCase(String a, String b, int i) {
    return indexOfIgnoreCase_manual(a, b, i);
  }

  static public <A> List<A> wrapArrayAsList(A[] a) {
    return a == null ? null : Arrays.asList(a);
  }

  static public Object[] concatArrays(Object[]... arrays) {
    int l = 0;
    for (Object[] a : arrays) l += l(a);
    Object[] x = new Object[l];
    int i = 0;
    for (Object[] a : arrays) if (a != null) {
      System.arraycopy(a, 0, x, i, l(a));
      i += l(a);
    }
    return x;
  }

  static public int clampToInt(long l) {
    return (int) clamp(l, Integer.MIN_VALUE, Integer.MAX_VALUE);
  }

  static public boolean isOpeningBracket(String s) {
    return eqOneOf(s, "(", "{", "[");
  }

  static public boolean containsClosingBracket(List<String> l) {
    return any(__75 -> isClosingBracket(__75), l);
  }

  static public boolean isClosingBracket(String s) {
    return eqOneOf(s, ")", "}", "]");
  }

  static public byte clampToUByte(long l) {
    return (byte) clamp(l, 0, 255);
  }

  static public <A> Comparator<A> reverseComparator(Comparator<A> c) {
    return (a, b) -> c.compare(b, a);
  }

  static public <A> Comparator<A> reverseComparator() {
    return (a, b) -> cmp(b, a);
  }

  static public BufferedImage drawImageOnImage(Image img, BufferedImage canvas, int x, int y) {
    createGraphics(canvas).drawImage(img, x, y, null);
    return canvas;
  }

  static public Graphics2D graphics(BufferedImage img) {
    return imageGraphics(img);
  }

  static public IMeta initMetaOfJComponent(JComponent c) {
    if (c == null)
      return null;
    IMeta meta = (IMeta) (c.getClientProperty(IMeta.class));
    if (meta == null)
      c.putClientProperty(IMeta.class, meta = new Meta());
    return meta;
  }

  static public void dynamicObject_setRawFieldValue(DynamicObject o, Object key, Object value) {
    if (o == null)
      return;
    synchronized (o) {
      o.fieldValues = syncMapPut2_createLinkedHashMap((LinkedHashMap) o.fieldValues, key, value);
    }
  }

  static public <A, B> AutoCloseable tempRemove(Map<A, B> map, A key) {
    if (map == null || !map.containsKey(key))
      return null;
    B b = map.get(key);
    map.remove(key);
    return new AutoCloseable() {

      public String toString() {
        return "map.put(key, b);";
      }

      public void close() throws Exception {
        map.put(key, b);
      }
    };
  }

  static public String uniqueFileNameUsingMD5_80(String fullName) {
    return md5(fullName) + " " + takeFirst(80 - 33, fileNameEncode(fullName));
  }

  static public File localMechListNameFile(String listName) {
    return newFile(localMechListsDir(), uniqueFileNameUsingMD5_80_v2(listName) + ".name");
  }

  static public File localMechListFile(String listName) {
    return newFile(localMechListsDir(), uniqueFileNameUsingMD5_80_v2(listName) + ".text");
  }

  static public void appendToMechList_noUniq_inQ(final String listName, final String text) {
    mechQ(new Runnable() {

      public void run() {
        try {
          appendToMechList_noUniq_plusLocal(listName, text);
        } catch (Exception __e) {
          throw rethrow(__e);
        }
      }

      public String toString() {
        return "appendToMechList_noUniq_plusLocal(listName, text)";
      }
    });
  }

  static public JLabel makeLabelBold(final JLabel l) {
    if (l != null) {
      swing(() -> {
        l.setFont(l.getFont().deriveFont(Font.BOLD));
      });
    }
    return l;
  }

  static public <A> A setThreadLocal(ThreadLocal<A> tl, A value) {
    if (tl == null)
      return null;
    A old = tl.get();
    tl.set(value);
    return old;
  }

  static public boolean isStringStartingWith(Object o, String prefix) {
    return o instanceof String && ((String) o).startsWith(prefix);
  }

  static public Map<String, Integer> tableColumnWidthsByName(JTable table) {
    TableColumnModel tcm = table.getColumnModel();
    if (tcm == null)
      return null;
    int n = tcm.getColumnCount();
    TreeMap<String, Integer> map = new TreeMap();
    for (int i = 0; i < n; i++) {
      TableColumn tc = tcm.getColumn(i);
      map.put(str(tc.getHeaderValue()), tc.getWidth());
    }
    return map;
  }

  static public int tableColumnCount(JTable table) {
    return tableNumColumns(table);
  }

  static public boolean tableSetColumnPreferredWidths_debug = false;

  static public void tableSetColumnPreferredWidths(final JTable table, final Map<String, Integer> widths) {
    if (table == null || widths == null)
      return;
    {
      swing(() -> {
        try {
          TableColumnModel tcm = table.getColumnModel();
          int n = tcm.getColumnCount();
          for (int i = 0; i < n; i++) {
            TableColumn tc = tcm.getColumn(i);
            Integer w = widths.get(str(tc.getHeaderValue()));
            if (w != null) {
              tc.setPreferredWidth(w);
              if (tableSetColumnPreferredWidths_debug)
                print("Setting preferred width of column " + i + " to " + w);
            }
          }
        } catch (Throwable __e) {
          printStackTrace(__e);
        }
      });
    }
  }

  static public void tableSetColumnPreferredWidths(JTable table, Object... widths) {
    tableSetColumnPreferredWidths(table, litorderedmap(widths));
  }

  static public int indexOfIgnoreCase_manual(String a, String b) {
    return indexOfIgnoreCase_manual(a, b, 0);
  }

  static public int indexOfIgnoreCase_manual(String a, String b, int i) {
    int la = strL(a), lb = strL(b);
    if (la < lb)
      return -1;
    int n = la - lb;
    loop: for (; i <= n; i++) {
      for (int j = 0; j < lb; j++) {
        char c1 = a.charAt(i + j), c2 = b.charAt(j);
        if (!eqic(c1, c2))
          continue loop;
      }
      return i;
    }
    return -1;
  }

  static public <A> boolean any(Object pred, Iterable<A> l) {
    if (l != null)
      for (A a : l) if (isTrue(callF(pred, a)))
        return true;
    return false;
  }

  static public <A> boolean any(IF1<A, Boolean> pred, Iterable<A> l) {
    return any((Object) pred, l);
  }

  static public <A> boolean any(Iterable<A> l, IF1<A, Boolean> pred) {
    return any(pred, l);
  }

  static public <A> boolean any(A[] l, IF1<A, Boolean> pred) {
    if (l != null)
      for (A a : l) if (pred.get(a))
        return true;
    return false;
  }

  static public boolean any(Iterable<Boolean> l) {
    if (l != null)
      for (Boolean a : l) if (isTrue(a))
        return true;
    return false;
  }

  static public <A, B> LinkedHashMap<A, B> syncMapPut2_createLinkedHashMap(LinkedHashMap<A, B> map, A key, B value) {
    if (key != null)
      if (value != null) {
        if (map == null)
          map = new LinkedHashMap();
        synchronized (collectionMutex(map)) {
          map.put(key, value);
        }
      } else if (map != null)
        synchronized (collectionMutex(map)) {
          map.remove(key);
        }
    return map;
  }

  static public File localMechListsDir() {
    return javaxDataDir("Mech Lists");
  }

  static public void mechQ(Runnable r) {
    mechAppendQueue(r);
  }

  static public String appendToMechList_noUniq_plusLocal(String name, String text) {
    logMechListAppendLocally(name, text);
    return botAppendToMechList(name, text);
  }

  static public int tableNumColumns(JTable table) {
    return table == null ? 0 : swing(new F0<Integer>() {

      public Integer get() {
        try {
          return table.getColumnCount();
        } catch (Exception __e) {
          throw rethrow(__e);
        }
      }

      public String toString() {
        return "return table.getColumnCount();";
      }
    });
  }

  static public Q mechAppendQueue_q;

  static public Lock mechAppendQueue_lock = lock();

  static public Q mechAppendQueue() {
    Lock __0 = mechAppendQueue_lock;
    lock(__0);
    try {
      if (mechAppendQueue_q == null)
        mechAppendQueue_q = startQ();
      return mechAppendQueue_q;
    } finally {
      unlock(__0);
    }
  }

  static public void mechAppendQueue(Runnable r) {
    mechAppendQueue().add(r);
  }

  static public String botAppendToMechList(String name, String text) {
    return botAppendToMechList_now(name, text);
  }

  static public Q startQ() {
    return new Q();
  }

  static public Q startQ(String name) {
    return new Q(name);
  }

  static public String botAppendToMechList_now(String name, String text) {
    return botAppendToMechList_mode(name, text, "noUniq");
  }

  static public String botAppendToMechList_mode(String name, String text, String mode) {
    if (empty(name) || empty(text))
      return "";
    String result = postPageSilently("http://butter.botcompany.de:8080/mech/raw/bot-list-append", arrayPlus(muricaCredentials(), "name", name, "text", text, "mode", mode));
    if (!swic(result, "No change")) {
      if (eq(mechMode().readMode, "localCopies")) {
        print("Appending to local list copy: " + name);
        appendToLocalMechListCopy(name, text);
      }
      mech_notifyBusOfChange(name);
      mechList_clearCache(name);
    }
    return result;
  }

  static public String botAppendToMechList_mode(String name, Collection<String> lines, String mode) {
    if (empty(lines))
      return "";
    return botAppendToMechList_mode(name, lines(lines), mode);
  }

  static public MechMode mechMode_value = new MechMode();

  static public MechMode mechMode() {
    return mechMode_value;
  }

  static public List<String> tlft(String s) {
    return toLinesFullTrim(s);
  }

  static public List<String> tlft(File f) {
    return toLinesFullTrim(f);
  }

  static public TreeSet<String> asCISet(Iterable<String> c) {
    return toCaseInsensitiveSet(c);
  }

  static public TreeSet<String> asCISet(String... x) {
    return toCaseInsensitiveSet(x);
  }

  static public void mech_notifyBusOfChange(String listName) {
    vmBus_send("mechChange", listName);
  }

  static public ThreadLocal<Boolean> mechList_clearCache_inFunction = new ThreadLocal();

  static public void mechList_clearCache(String listName) {
    {
      AutoCloseable __1 = tempSetTL(mechList_clearCache_inFunction, true);
      try {
        print("Sending mech clear: " + listName);
        vmBus_send("mechList_clearCache", listName);
      } finally {
        _close(__1);
      }
    }
    mechList_clearCache_noSend(listName);
  }

  static public void mechList_clearCache_noSend(String listName) {
    for (String field : mcFields()) if (startsWithEndsWith(field, "mech", "_cache")) {
      Object o = getOptMC(field);
      if (o instanceof Map)
        removeFromMapCI_sync((Map) o, listName);
    }
  }

  static public String postPageSilently(String url, Object... params) {
    return doPostSilently(litmap(params), url);
  }

  static public boolean swic(String a, String b) {
    return startsWithIgnoreCase(a, b);
  }

  static public boolean swic(String a, String b, Matches m) {
    if (!swic(a, b))
      return false;
    m.m = new String[] { substring(a, l(b)) };
    return true;
  }

  static public void appendToLocalMechListCopy(String listName, String text) {
    appendToTextFile(remoteMechListMirrorFile(listName), "\n" + text);
  }

  static public List<String> toLinesFullTrim(String s) {
    List<String> l = new ArrayList();
    for (String line : toLines(s)) if (nempty(line = trim(line)))
      l.add(line);
    return l;
  }

  static public List<String> toLinesFullTrim(File f) {
    List<String> l = new ArrayList();
    for (String line : linesFromFile(f)) if (nempty(line = trim(line)))
      l.add(line);
    return l;
  }

  static public TreeSet<String> toCaseInsensitiveSet(Iterable<String> c) {
    if (isCISet(c))
      return (TreeSet) c;
    TreeSet<String> set = caseInsensitiveSet();
    addAll(set, c);
    return set;
  }

  static public TreeSet<String> toCaseInsensitiveSet(String... x) {
    TreeSet<String> set = caseInsensitiveSet();
    addAll(set, x);
    return set;
  }

  static public Set<String> mcFields() {
    return staticFieldNames(mc());
  }

  static public boolean startsWithEndsWith(String s, String prefix, String suffix) {
    return startsWith(s, prefix) && endsWith(s, suffix);
  }

  static public boolean startsWithEndsWith(String s, String prefixSuffix) {
    return startsWithEndsWith(s, prefixSuffix, prefixSuffix);
  }

  static public void removeFromMapCI_sync(Map<String, Object> map, String key) {
    if (map == null)
      return;
    synchronized (getMutex(map)) {
      for (String k : cloneList(keys(map))) if (eqic(key, k))
        map.remove(k);
    }
  }

  static public String doPostSilently(Map urlParameters, String url) {
    return doPostSilently(makePostData(urlParameters), url);
  }

  static public String doPostSilently(String urlParameters, String url) {
    doPost_silently.set(true);
    return doPost(urlParameters, url);
  }

  static public boolean startsWithIgnoreCase(String a, String b) {
    return regionMatchesIC(a, 0, b, 0, b.length());
  }

  static public void appendToTextFile(File file, String s) {
    appendToFile(file, s);
  }

  static public void appendToTextFile(String file, String s) {
    appendToTextFile(programFile(file), s);
  }

  static public File remoteMechListMirrorFile(String listName) {
    return newFile(remoteMechListMirrorsDir(), uniqueFileNameUsingMD5_80_v2(upper(listName)));
  }

  static public Set<String> staticFieldNames(Object o) {
    TreeSet<String> fields = new TreeSet();
    Class _c = _getClass(o);
    do {
      for (Field f : _c.getDeclaredFields()) if ((f.getModifiers() & Modifier.STATIC) != 0)
        fields.add(f.getName());
      _c = _c.getSuperclass();
    } while (_c != null);
    return fields;
  }

  static public Object getMutex(Object o) {
    return collectionMutex(o);
  }

  static public String makePostData(Map map) {
    StringBuilder buf = new StringBuilder();
    for (Map.Entry<Object, Object> e : castMapToMapO(map).entrySet()) {
      String key = (String) (e.getKey());
      Object val = e.getValue();
      if (val != null) {
        String value = str(val);
        if (nempty(buf))
          buf.append("&");
        buf.append(urlencode(key)).append("=").append(urlencode((value)));
      }
    }
    return str(buf);
  }

  static public String makePostData(Object... params) {
    StringBuilder buf = new StringBuilder();
    int n = l(params);
    for (int i = 0; i + 1 < n; i += 2) {
      String key = (String) (params[i]);
      Object val = params[i + 1];
      if (val != null) {
        String value = str(val);
        if (nempty(buf))
          buf.append("&");
        buf.append(urlencode(key)).append("=").append(urlencode((value)));
      }
    }
    return str(buf);
  }

  static public ThreadLocal<Boolean> doPost_silently = new ThreadLocal();

  static public ThreadLocal<Long> doPost_timeout = new ThreadLocal();

  static public ThreadLocal<Map<String, String>> doPost_extraHeaders = new ThreadLocal();

  static public String doPost(String url, Map urlParameters) {
    return doPost(urlParameters, url);
  }

  static public String doPost(Map urlParameters, String url) {
    return doPost(makePostData(urlParameters), url);
  }

  static public String doPost(String urlParameters, String url) {
    try {
      URL _url = new URL(url);
      ping();
      return doPost(urlParameters, _url.openConnection(), _url);
    } catch (Exception __e) {
      throw rethrow(__e);
    }
  }

  static public String doPost(String urlParameters, URLConnection conn, URL url) {
    try {
      boolean silently = isTrue(optParam(doPost_silently));
      Long timeout = optParam(doPost_timeout);
      Map<String, String> extraHeaders = optPar(doPost_extraHeaders);
      setHeaders(conn);
      for (String key : keys(extraHeaders)) {
        conn.setRequestProperty(key, extraHeaders.get(key));
      }
      int l = lUtf8(urlParameters);
      if (!silently)
        print("Sending POST request: " + hideCredentials(url) + " (" + l + " bytes)");
      if (timeout != null)
        setURLConnectionTimeouts(conn, timeout);
      ((HttpURLConnection) conn).setRequestMethod("POST");
      conn.setDoOutput(true);
      conn.setRequestProperty("Content-Length", str(l));
      OutputStreamWriter writer = new OutputStreamWriter(conn.getOutputStream(), "UTF-8");
      writer.write(urlParameters);
      writer.flush();
      String contents = loadPage_utf8(conn, url, false);
      writer.close();
      return contents;
    } catch (Exception __e) {
      throw rethrow(__e);
    }
  }

  static public File programFile(String name) {
    return prepareProgramFile(name);
  }

  static public File programFile(String progID, String name) {
    return prepareProgramFile(progID, name);
  }

  static public File remoteMechListMirrorsDir() {
    return javaxDataDir("Remote Mech Lists");
  }

  static public String upper(String s) {
    return s == null ? null : s.toUpperCase();
  }

  static public char upper(char c) {
    return Character.toUpperCase(c);
  }

  static public Map<Object, Object> castMapToMapO(Map map) {
    return map;
  }

  static public String urlencode(String x) {
    try {
      return URLEncoder.encode(unnull(x), "UTF-8");
    } catch (UnsupportedEncodingException e) {
      throw new RuntimeException(e);
    }
  }

  static public int lUtf8(String s) {
    return l(utf8(s));
  }

  static abstract public class VF2<A, B> {

    abstract public void get(A a, B b);
  }

  static public class ImageChooser extends SingleComponentPanel {

    public ImageSurface is = new ImageSurface();

    public JTextField tfPath = new JTextField();

    public ImageChooser(BufferedImage img) {
      this();
      setImage(img);
    }

    public ImageChooser(RGBImage img) {
      this(img.getBufferedImage());
    }

    public ImageChooser() {
      bindToComponent(this, new Runnable() {

        public void run() {
          try {
            is.zoomToWindow();
          } catch (Exception __e) {
            throw rethrow(__e);
          }
        }

        public String toString() {
          return "is.zoomToWindow()";
        }
      });
      is.loadFromClipboard();
      setComponent(jMinSize(100, 100, jscroll(is)));
      componentPopupMenu(is, new VF1<JPopupMenu>() {

        public void get(JPopupMenu menu) {
          try {
            addMenuItem(menu, "Screenshot in 3", new Runnable() {

              public void run() {
                try {
                  startThread("Screenshot in 3", new Runnable() {

                    public void run() {
                      try {
                        sleep(3000);
                        final BufferedImage img = shootScreen2();
                        swingLater(new Runnable() {

                          public void run() {
                            try {
                              is.setImage(img);
                              infoMessage("Screenshot taken (" + img.getWidth() + "*" + img.getHeight() + " px)", 2);
                            } catch (Exception __e) {
                              throw rethrow(__e);
                            }
                          }

                          public String toString() {
                            return "is.setImage(img);\r\n            infoMessage(\"Screenshot taken (\" + img.getWidt...";
                          }
                        });
                      } catch (Exception __e) {
                        throw rethrow(__e);
                      }
                    }

                    public String toString() {
                      return "sleep(3000);\r\n          final BufferedImage img = shootScreen2();\r\n          ...";
                    }
                  });
                } catch (Exception __e) {
                  throw rethrow(__e);
                }
              }

              public String toString() {
                return "thread \"Screenshot in 3\" {\r\n          sleep(3000);\r\n          final BufferedI...";
              }
            });
            addMenuItem(menu, "Load snippet or file...", new Runnable() {

              public void run() {
                try {
                  final JTextField tf = new JTextField();
                  showFormTitled("Load image from snippet or file", "Path or snippet ID", tf, new Runnable() {

                    public void run() {
                      try {
                        is.setImage(loadImage2(tf.getText().trim()));
                        is.zoomToDisplaySize();
                      } catch (Exception __e) {
                        throw rethrow(__e);
                      }
                    }

                    public String toString() {
                      return "is.setImage(loadImage2(tf.getText().trim()));\r\n            is.zoomToDisplaySi...";
                    }
                  });
                } catch (Exception __e) {
                  throw rethrow(__e);
                }
              }

              public String toString() {
                return "final new JTextField tf;\r\n        showFormTitled(\"Load image from snippet or ...";
              }
            });
          } catch (Exception __e) {
            throw rethrow(__e);
          }
        }

        public String toString() {
          return "addMenuItem(menu, \"Screenshot in 3\", r {\r\n        thread \"Screenshot in 3\" {\r...";
        }
      });
    }

    public boolean hasImage() {
      return is.getImage() != null && is.getImage().getWidth() * is.getImage().getHeight() > 1;
    }

    public BWImage getBWImage() {
      return is.getImage() == null ? null : new BWImage(is.getImage());
    }

    public BufferedImage getImage() {
      return hasImage() ? is.getImage() : null;
    }

    public void setImage(BufferedImage img) {
      is.setImage(img);
      is.zoomToWindow();
    }

    public void setTitleForUpload(String title) {
      is.titleForUpload = title;
    }
  }

  static public class SingleThread {

    public boolean running = false;

    public void run(Object r) {
      go(r);
    }

    synchronized public boolean go(final Object runnable) {
      if (running)
        return false;
      running = true;
      startThread("Single Thread", new Runnable() {

        public void run() {
          try {
            try {
              callF(runnable);
            } finally {
              _done();
            }
          } catch (Exception __e) {
            throw rethrow(__e);
          }
        }

        public String toString() {
          return "try {\r\n        callF(runnable);\r\n      } finally {\r\n        _done();\r\n      }";
        }
      });
      return true;
    }

    synchronized public void _done() {
      running = false;
    }

    public boolean running() {
      return running;
    }
  }

  static public class IntVar {

    public int a;

    public synchronized void set(int v) {
      if (v != a) {
        a = v;
        notifyAll();
      }
    }

    public synchronized int get() {
      return a;
    }

    synchronized public int waitForValue(int x) {
      try {
        while (a != x) wait();
        return a;
      } catch (Exception __e) {
        throw rethrow(__e);
      }
    }
  }

  static final public class IntPair implements Comparable<IntPair>, IFieldsToList {

    public int a;

    public int b;

    public IntPair() {
    }

    public IntPair(int a, int b) {
      this.b = b;
      this.a = a;
    }

    public String toString() {
      return shortClassName_dropNumberPrefix(this) + "(" + a + ", " + b + ")";
    }

    public Object[] _fieldsToList() {
      return new Object[] { a, b };
    }

    public boolean equals(Object o) {
      if (!(o instanceof IntPair))
        return false;
      IntPair x = (IntPair) o;
      return a == x.a && b == x.b;
    }

    public int hashCode() {
      int h = -672893111;
      h = boostHashCombine(h, _hashCode(a));
      h = boostHashCombine(h, _hashCode(b));
      return h;
    }

    public int compareTo(IntPair p) {
      if (p == null)
        return 1;
      int pa = p.a;
      if (a < pa)
        return -1;
      if (a > pa)
        return 1;
      return Integer.compare(b, p.b);
    }
  }

  static public class RasterBars extends Animation {

    public List<Pair<IntRange, Integer>> streaks;

    public RasterBars() {
    }

    public RasterBars(int w, int h, List<Pair<IntRange, Integer>> streaks) {
      this.streaks = streaks;
      this.h = h;
      this.w = w;
    }

    public void paint() {
      for (var streak : streaks) fillRect(g, 0, streak.a.start, w, l(streak.a), grayToColor(streak.b));
    }
  }

  static public class CountingOutputStream extends FilterOutputStream {

    public long counter;

    public CountingOutputStream(OutputStream out) {
      super(out);
    }

    @Override
    public void write(int b) throws IOException {
      ++counter;
      out.write(b);
    }

    @Override
    public void write(byte[] b) throws IOException {
      counter += b.length;
      out.write(b, 0, b.length);
    }

    @Override
    public void write(byte[] b, int off, int len) throws IOException {
      if (len == 0)
        return;
      counter += len;
      out.write(b, off, len);
    }

    public long getFilePointer() {
      return counter;
    }
  }

  static public class AppendableChain<A> extends MinimalChain<A> implements Iterable<A> {

    public MinimalChain<A> last;

    public int size;

    public AppendableChain() {
    }

    public AppendableChain(A element) {
      this.element = element;
      size = 1;
      last = this;
    }

    public AppendableChain(A element, AppendableChain<A> next) {
      this.next = next;
      this.element = element;
      if (next == null)
        return;
      MinimalChain<A> b = new MinimalChain();
      b.element = next.element;
      b.next = next.next;
      this.next = b;
      last = next.last;
      size = next.size + 1;
    }

    public String toString() {
      return str(toList());
    }

    public boolean add(A a) {
      MinimalChain newLast = new MinimalChain(a);
      last.next = newLast;
      last = newLast;
      ++size;
      return true;
    }

    public AppendableChain<A> popFirst() {
      if (next == null)
        return null;
      element = next.element;
      if (last == next)
        last = this;
      next = next.next;
      --size;
      return this;
    }

    public ArrayList<A> toList() {
      ArrayList<A> l = emptyList(size);
      MinimalChain<A> c = this;
      while (c != null) {
        l.add(c.element);
        c = c.next;
      }
      return l;
    }

    public class ACIt extends IterableIterator<A> {

      public MinimalChain<A> c = AppendableChain.this;

      public boolean hasNext() {
        return c != null;
      }

      public A next() {
        var a = c.element;
        c = c.next;
        return a;
      }
    }

    public IterableIterator<A> iterator() {
      return new ACIt();
    }
  }

  static public class Value<A> implements IF0<A>, IFieldsToList {

    public A value;

    public Value() {
    }

    public Value(A value) {
      this.value = value;
    }

    public boolean equals(Object o) {
      if (!(o instanceof Value))
        return false;
      Value __1 = (Value) o;
      return eq(value, __1.value);
    }

    public int hashCode() {
      int h = 82420049;
      h = boostHashCombine(h, _hashCode(value));
      return h;
    }

    public Object[] _fieldsToList() {
      return new Object[] { value };
    }

    public A get() {
      return value;
    }

    public String toString() {
      return str(get());
    }
  }

  static public class WeakIdentityHashMap<K, V> implements Map<K, V> {

    final public ReferenceQueue<K> queue = new ReferenceQueue<K>();

    public Map<IdentityWeakReference, V> backingStore = new HashMap<IdentityWeakReference, V>();

    public WeakIdentityHashMap() {
      _registerWeakMap(this);
    }

    public synchronized void clear() {
      backingStore.clear();
      reap();
    }

    public synchronized boolean containsKey(Object key) {
      reap();
      return backingStore.containsKey(new IdentityWeakReference(key));
    }

    public synchronized boolean containsValue(Object value) {
      reap();
      return backingStore.containsValue(value);
    }

    public synchronized Set<Map.Entry<K, V>> entrySet() {
      reap();
      Set<Map.Entry<K, V>> ret = new HashSet<Map.Entry<K, V>>();
      for (Map.Entry<IdentityWeakReference, V> ref : backingStore.entrySet()) {
        final K key = ref.getKey().get();
        final V value = ref.getValue();
        Map.Entry<K, V> entry = new Map.Entry<K, V>() {

          public synchronized K getKey() {
            return key;
          }

          public synchronized V getValue() {
            return value;
          }

          public synchronized V setValue(V value) {
            throw new UnsupportedOperationException();
          }
        };
        ret.add(entry);
      }
      return Collections.unmodifiableSet(ret);
    }

    public synchronized Set<K> keySet() {
      reap();
      IdentityHashMap<K, Boolean> map = new IdentityHashMap();
      for (IdentityWeakReference ref : backingStore.keySet()) {
        K k = ref.get();
        if (k != null)
          map.put(k, Boolean.TRUE);
      }
      return map.keySet();
    }

    public synchronized boolean equals(Object o) {
      if (!(o instanceof WeakIdentityHashMap)) {
        return false;
      }
      return backingStore.equals(((WeakIdentityHashMap) o).backingStore);
    }

    public synchronized V get(Object key) {
      reap();
      return backingStore.get(new IdentityWeakReference(key));
    }

    public synchronized V put(K key, V value) {
      reap();
      return backingStore.put(new IdentityWeakReference(key), value);
    }

    public synchronized int hashCode() {
      reap();
      return backingStore.hashCode();
    }

    public synchronized boolean isEmpty() {
      reap();
      return backingStore.isEmpty();
    }

    public synchronized void putAll(Map t) {
      throw new UnsupportedOperationException();
    }

    public synchronized V remove(Object key) {
      reap();
      return backingStore.remove(new IdentityWeakReference(key));
    }

    public synchronized int size() {
      reap();
      return backingStore.size();
    }

    public synchronized Collection<V> values() {
      reap();
      return backingStore.values();
    }

    synchronized final public void reap() {
      Object zombie = queue.poll();
      while (zombie != null) {
        IdentityWeakReference victim = (IdentityWeakReference) zombie;
        backingStore.remove(victim);
        zombie = queue.poll();
      }
    }

    public class IdentityWeakReference extends WeakReference<K> {

      public int hash;

      @SuppressWarnings("unchecked")
      public IdentityWeakReference(Object obj) {
        super((K) obj, queue);
        hash = System.identityHashCode(obj);
      }

      public synchronized int hashCode() {
        return hash;
      }

      public synchronized boolean equals(Object o) {
        if (this == o) {
          return true;
        }
        if (!(o instanceof WeakIdentityHashMap.IdentityWeakReference)) {
          return false;
        }
        IdentityWeakReference ref = (IdentityWeakReference) o;
        if (this.get() == ref.get()) {
          return true;
        }
        return false;
      }
    }
  }

  static public interface IF2_IntInt_Double {

    public double get(int a, int b);
  }

  static public class NumPadFixingInputMap extends InputMap {

    public void put(KeyStroke keyStroke, Object actionMapKey) {
      super.put(keyStroke, actionMapKey);
      Integer code = rsyntaxTextArea_fixNumPad_map.get(keyStroke.getKeyCode());
      if (code != null)
        put(KeyStroke.getKeyStroke(code, keyStroke.getModifiers()), actionMapKey);
    }

    public void replaceOn(JComponent c) {
      InputMap im = c.getInputMap();
      setParent(im.getParent());
      for (KeyStroke key : im.keys()) put(key, im.get(key));
      c.setInputMap(JComponent.WHEN_FOCUSED, this);
    }
  }

  static public class MechMode implements IFieldsToList {

    public Object readMode;

    public Object writeMode;

    public MechMode() {
    }

    public MechMode(Object readMode, Object writeMode) {
      this.writeMode = writeMode;
      this.readMode = readMode;
    }

    public String toString() {
      return shortClassName_dropNumberPrefix(this) + "(" + readMode + ", " + writeMode + ")";
    }

    public boolean equals(Object o) {
      if (!(o instanceof MechMode))
        return false;
      MechMode __1 = (MechMode) o;
      return eq(readMode, __1.readMode) && eq(writeMode, __1.writeMode);
    }

    public int hashCode() {
      int h = -866263200;
      h = boostHashCombine(h, _hashCode(readMode));
      h = boostHashCombine(h, _hashCode(writeMode));
      return h;
    }

    public Object[] _fieldsToList() {
      return new Object[] { readMode, writeMode };
    }
  }

  abstract static public class NotifyingSet<A> extends NotifyingCollection<A> implements Set<A> {

    public Set<A> set;

    public NotifyingSet() {
    }

    public NotifyingSet(Set<A> set) {
      super(set);
      this.set = set;
    }
  }

  static public class TimeoutException extends RuntimeException implements IFieldsToList {

    public double timeoutSeconds;

    public Object function;

    public Thread thread;

    public TimeoutException() {
    }

    public TimeoutException(double timeoutSeconds, Object function, Thread thread) {
      this.thread = thread;
      this.function = function;
      this.timeoutSeconds = timeoutSeconds;
    }

    public String toString() {
      return shortClassName_dropNumberPrefix(this) + "(" + timeoutSeconds + ", " + function + ", " + thread + ")";
    }

    public Object[] _fieldsToList() {
      return new Object[] { timeoutSeconds, function, thread };
    }

    @Override
    public String getMessage() {
      return "Timeout after " + iceil(timeoutSeconds) + "s by " + shorten_str(function);
    }
  }

  static public class WeakIdentityHashSet<A> extends AbstractSet<A> {

    public Map<A, Boolean> map = newWeakIdentityHashMap();

    public int size() {
      return map.size();
    }

    public Iterator<A> iterator() {
      return keys(map).iterator();
    }

    public boolean contains(Object o) {
      return map.containsKey(o);
    }

    public boolean add(A a) {
      return map.put(a, Boolean.TRUE) != null;
    }

    public boolean remove(Object o) {
      return map.remove(o) != null;
    }

    public Object mutex() {
      return collectionMutex(map);
    }
  }

  abstract static public class NotifyingCollection<E> extends AbstractCollection<E> implements Collection<E> {

    public Collection<E> c;

    public NotifyingCollection() {
    }

    public NotifyingCollection(Collection<E> c) {
      this.c = c;
    }

    public int size() {
      synchronized (this) {
        return c.size();
      }
    }

    public boolean isEmpty() {
      synchronized (this) {
        return c.isEmpty();
      }
    }

    public boolean contains(Object o) {
      synchronized (this) {
        return c.contains(o);
      }
    }

    public Object[] toArray() {
      synchronized (this) {
        return c.toArray();
      }
    }

    public <T> T[] toArray(T[] a) {
      synchronized (this) {
        return c.toArray(a);
      }
    }

    public Iterator<E> iterator() {
      return c.iterator();
    }

    public boolean add(E e) {
      synchronized (this) {
        if (!c.add(e))
          return false;
      }
      change();
      return true;
    }

    public boolean remove(Object o) {
      synchronized (this) {
        if (!c.remove(o))
          return false;
      }
      change();
      return true;
    }

    public boolean containsAll(Collection<?> coll) {
      synchronized (this) {
        return c.containsAll(coll);
      }
    }

    public boolean addAll(Collection<? extends E> coll) {
      synchronized (this) {
        if (!c.addAll(coll))
          return false;
      }
      change();
      return true;
    }

    public boolean removeAll(Collection<?> coll) {
      synchronized (this) {
        if (!c.removeAll(coll))
          return false;
      }
      change();
      return true;
    }

    public boolean retainAll(Collection<?> coll) {
      synchronized (this) {
        if (!c.retainAll(coll))
          return false;
      }
      change();
      return true;
    }

    public void clear() {
      synchronized (this) {
        c.clear();
      }
      change();
    }

    public String toString() {
      synchronized (this) {
        return c.toString();
      }
    }

    @Override
    public Spliterator<E> spliterator() {
      return c.spliterator();
    }

    abstract public void change();

    public Collection<E> unwrap() {
      return c;
    }
  }

  static public class MinimalChain<A> implements Iterable<A> {

    public A element;

    public MinimalChain<A> next;

    public MinimalChain() {
    }

    public MinimalChain(A element) {
      this.element = element;
    }

    public MinimalChain(A element, MinimalChain<A> next) {
      this.next = next;
      this.element = element;
    }

    public String toString() {
      return str(toList());
    }

    public ArrayList<A> toList() {
      ArrayList<A> l = new ArrayList();
      MinimalChain<A> c = this;
      while (c != null) {
        l.add(c.element);
        c = c.next;
      }
      return l;
    }

    public void setElement(A a) {
      element = a;
    }

    public void setNext(MinimalChain<A> next) {
      this.next = next;
    }

    public Iterator<A> iterator() {
      return toList().iterator();
    }

    public A get() {
      return element;
    }
  }

  static public GlobalID aGlobalIDObjUnlessLoading() {
    return dynamicObjectIsLoading() ? null : aGlobalIDObj();
  }

  static public <A extends Component> A jMinSize(int w, int h, A c) {
    return jMinWidth(w, jMinHeight(h, c));
  }

  static public <A extends Component> A jMinSize(A c, Dimension d) {
    return jMinSize(d.width, d.height, c);
  }

  static public Color grayToColor(double f) {
    return toColor(brightnessToRGBA(iceil(f * 256)));
  }

  static public List _registerWeakMap_preList;

  static public <A> A _registerWeakMap(A map) {
    if (javax() == null) {
      if (_registerWeakMap_preList == null)
        _registerWeakMap_preList = synchroList();
      _registerWeakMap_preList.add(map);
      return map;
    }
    try {
      call(javax(), "_registerWeakMap", map);
    } catch (Throwable e) {
      printException(e);
      print("Upgrade JavaX!!");
    }
    return map;
  }

  static public void _onLoad_registerWeakMap() {
    assertNotNull(javax());
    if (_registerWeakMap_preList == null)
      return;
    for (Object o : _registerWeakMap_preList) _registerWeakMap(o);
    _registerWeakMap_preList = null;
  }

  static public <A, B> WeakIdentityHashMap<A, B> newWeakIdentityHashMap() {
    return new WeakIdentityHashMap();
  }

  static public JComponent unwrap(JComponent c) {
    return c instanceof JScrollPane ? unwrapScrollPane((JScrollPane) c) : c;
  }

  static public GlobalID aGlobalIDObj() {
    return asGlobalID(randomID(16));
  }

  static public GlobalID aGlobalIDObj(Random random) {
    return asGlobalID(randomID(random, 16));
  }

  static public <A extends Component> A jMinWidth(final int w, final A c) {
    if (c == null)
      return null;
    return swing(new F0<A>() {

      public A get() {
        try {
          Dimension size = c.getMinimumSize();
          c.setMinimumSize(new Dimension(w, size.height));
          return jPreferWidth(w, c);
        } catch (Exception __e) {
          throw rethrow(__e);
        }
      }

      public String toString() {
        return "Dimension size = c.getMinimumSize();\r\n    c.setMinimumSize(new Dimension(/*ma...";
      }
    });
  }

  static public Color toColor(RGB rgb) {
    return rgb == null ? null : rgb.getColor();
  }

  static public Color toColor(int rgb) {
    return new Color(rgb);
  }

  static public Color toColor(String hex) {
    return awtColor(hex);
  }

  static public Color toColor(int[] rgb) {
    return new Color(rgb[0], rgb[1], rgb[2]);
  }

  static public <A extends Throwable> A printException(A e) {
    printStackTrace(e);
    return e;
  }

  static public JComponent unwrapScrollPane(JScrollPane sp) {
    return sp == null ? null : (JComponent) sp.getViewport().getView();
  }

  static public GlobalID asGlobalID(String id) {
    return id == null ? null : new GlobalID(id);
  }

  static public int randomID_defaultLength = 12;

  static public String randomID(int length) {
    return makeRandomID(length);
  }

  static public String randomID(Random r, int length) {
    return makeRandomID(r, length);
  }

  static public String randomID() {
    return randomID(randomID_defaultLength);
  }

  static public String randomID(Random r) {
    return randomID(r, randomID_defaultLength);
  }
}