import java.util.*;
import java.util.zip.*;
import java.util.List;
import java.util.regex.*;
import java.util.concurrent.*;
import java.util.concurrent.atomic.*;
import java.util.concurrent.locks.*;
import java.util.function.*;
import javax.swing.*;
import javax.swing.event.*;
import javax.swing.text.*;
import javax.swing.table.*;
import java.io.*;
import java.net.*;
import java.lang.reflect.*;
import java.lang.ref.*;
import java.lang.management.*;
import java.security.*;
import java.security.spec.*;
import java.awt.*;
import java.awt.event.*;
import java.awt.image.*;
import java.awt.geom.*;
import javax.imageio.*;
import java.math.*;
import java.awt.geom.*;
import static x30_pkg.x30_util.DynamicObject;
class main {
static Steppable combineSteppables_dontDropEnded(Iterable extends Steppable> steppables) {
List extends Steppable> steppablesList = nonNulls(steppables);
return () -> {
boolean change = false;
for (var s : steppablesList)
change |= s.step();
return change;
};
}
static Steppable combineSteppables_dontDropEnded(A... steppables) {
return combineSteppables(asList(steppables));
}
static List nonNulls(Iterable l) {
return withoutNulls(l);
}
static List nonNulls(A[] l) {
return withoutNulls(l);
}
static Map nonNulls(Map map) {
return withoutNulls(map);
}
static Steppable combineSteppables(Iterable extends Steppable> steppables) {
return iteratorToSteppable(roundRobinCombinedIterator(map(__16 -> steppableToIterator(__16), steppables)));
}
static Steppable combineSteppables(A... steppables) {
return combineSteppables(asList(steppables));
}
// unclear semantics as to whether return null on null
static ArrayList asList(A[] a) {
return a == null ? new ArrayList() : new ArrayList(Arrays.asList(a));
}
static ArrayList asList(int[] a) {
if (a == null) return null;
ArrayList l = emptyList(a.length);
for (int i : a) l.add(i);
return l;
}
static ArrayList asList(long[] a) {
if (a == null) return null;
ArrayList l = emptyList(a.length);
for (long i : a) l.add(i);
return l;
}
static ArrayList asList(float[] a) {
if (a == null) return null;
ArrayList l = emptyList(a.length);
for (float i : a) l.add(i);
return l;
}
static ArrayList asList(double[] a) {
if (a == null) return null;
ArrayList l = emptyList(a.length);
for (double i : a) l.add(i);
return l;
}
static ArrayList asList(short[] a) {
if (a == null) return null;
ArrayList l = emptyList(a.length);
for (short i : a) l.add(i);
return l;
}
static ArrayList asList(Iterator it) {
ArrayList l = new ArrayList();
if (it != null)
while (it.hasNext())
l.add(it.next());
return l;
}
// disambiguation
static ArrayList asList(IterableIterator s) {
return asList((Iterator) s);
}
static ArrayList asList(Iterable 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 ArrayList asList(Enumeration e) {
ArrayList l = new ArrayList();
if (e != null)
while (e.hasMoreElements())
l.add(e.nextElement());
return l;
}
static List asList(Pair p) {
return p == null ? null : ll(p.a, p.b);
}
static List withoutNulls(Iterable l) {
if (l instanceof List)
if (!containsNulls((List) l)) return ((List) l);
List l2 = new ArrayList();
for (A a : l)
if (a != null)
l2.add(a);
return l2;
}
static Map withoutNulls(Map map) {
Map 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 List withoutNulls(A[] l) {
List l2 = new ArrayList();
if (l != null) for (A a : l)
if (a != null)
l2.add(a);
return l2;
}
static Steppable iteratorToSteppable(Iterator it) {
return it == null ? null : new Steppable() {
public boolean step() {
if (!it.hasNext()) return false;
it.next();
return true;
}
};
}
static IterableIterator roundRobinCombinedIterator(Iterator... iterators) {
return roundRobinCombinedIterator(wrapAsList(iterators));
}
static IterableIterator roundRobinCombinedIterator(Collection extends Iterator> iterators) {
if (empty(iterators)) return emptyItIt();
class Robin implements IF0 {
List extends Iterator> activeIterators = cloneList(iterators);
int i;
public Object get() {
while (licensed()) {
Iterator it = activeIterators.get(i);
if (!it.hasNext()) {
activeIterators.remove(i);
if (empty(activeIterators)) break;
i %= l(activeIterators);
} else {
i = (i+1) % l(activeIterators);
return it.next();
}
}
return endMarker();
}
}
return iff(new Robin());
}
static List map(Iterable l, Object f) { return map(f, l); }
static List map(Object f, Iterable l) {
List x = emptyList(l);
if (l != null) for (Object o : l)
{ ping(); x.add(callF(f, o)); }
return x;
}
// map: func(key, value) -> list element
static List map(Map map, Object f) {
List x = new ArrayList();
if (map != null) for (Object _e : map.entrySet()) { ping();
Map.Entry e = (Map.Entry) _e;
x.add(callF(f, e.getKey(), e.getValue()));
}
return x;
}
static List map(Object f, Object[] l) { return map(f, asList(l)); }
static List map(Object[] l, Object f) { return map(f, l); }
static List map(Object f, Map map) {
return map(map, f);
}
static List map(Iterable l, F1 f) { return map(f, l); }
static List map(F1 f, Iterable l) {
List x = emptyList(l);
if (l != null) for (A o : l)
{ ping(); x.add(callF(f, o)); }
return x;
}
static List map(IF1 f, Iterable l) { return map(l, f); }
static List map(Iterable l, IF1 f) {
List x = emptyList(l);
if (l != null) for (A o : l)
{ ping(); x.add(f.get(o)); }
return x;
}
static List map(IF1 f, A[] l) { return map(l, f); }
static List map(A[] l, IF1 f) {
List x = emptyList(l);
if (l != null) for (A o : l)
{ ping(); x.add(f.get(o)); }
return x;
}
static List map(Map map, IF2 f) {
List x = new ArrayList();
if (map != null) for (Map.Entry e : map.entrySet()) { ping();
x.add(f.get(e.getKey(), e.getValue()));
}
return x;
}
// new magic alias for mapLL - does it conflict?
static List map(IF1 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 IterableIterator