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 javax.swing.*;
import javax.swing.event.*;
import javax.swing.text.*;
import javax.swing.table.*;
import java.io.*;
import java.net.*;
import java.lang.reflect.*;
import java.lang.ref.*;
import java.lang.management.*;
import java.security.*;
import java.security.spec.*;
import java.awt.*;
import java.awt.event.*;
import java.awt.image.*;
import javax.imageio.*;
import java.math.*;
import static x30_pkg.x30_util.DynamicObject;
import java.text.SimpleDateFormat;
import java.nio.charset.Charset;
import java.text.NumberFormat;
class main {
static class URecognizer {
IIntegralImage image;
URecognizer() {}
URecognizer(IIntegralImage image) {
this.image = image;}
URecognizer(BufferedImage image) {
this.image = new IntegralImage(image);
}
// returns 0, 1 or 2
int posterizeToInt(double x) {
return ifloor(clampZeroToOne(x)*3);
}
// returns 0, .5 or 1
double posterizeInPlace(double x) {
return posterizeToInt(x)*.5;
}
class Cell {
// Original image and which part we are looking at
DoubleRange xClip, yClip;
// color transformations in place
DoubleRange[] colorClips = new DoubleRange[3];
Cell copy() {
Cell c = new Cell();
c.xClip = xClip;
arrayCopy(colorClips, c.colorClips);
return c;
}
Rect rectInImage() {
return toRect_floor(doubleRectFromRanges(xClip, yClip));
}
// get color of cell
double color(int channel) {
double color = ii_averageBrightnessOfArea(image, rectInImage(), channel);
return transformBetweenDoubleRanges(color, colorClips[channel], zeroToOne());
}
// unposterized color of all 3 channels
double[] color() {
double[] c = new double[3];
for (int i = 0; i < 3; i++)
c[i] = color(i);
return c;
}
public String toString() {
return "Color: " + asList(color());
}
int posterizedIntColor(int channel) {
return posterizeToInt(color(channel));
}
// get sub-cells
Cell[] xSplit() {
Cell[] cells = new Cell[3];
for (int i = 0; i < 3; i++) cells[i] = xSlice(i/3.0, (i+1)/3.0);
return cells;
}
Cell xSlice(double a, double b) {
Cell c = copy();
c.xClip = transformBetweenDoubleRanges(new DoubleRange(a, b), zeroToOne(), xClip);
return c;
}
Cell[] ySplit() {
Cell[] cells = new Cell[3];
for (int i = 0; i < 3; i++) cells[i] = ySlice(i/3.0, (i+1)/3.0);
return cells;
}
Cell ySlice(double a, double b) {
Cell c = copy();
c.yClip = transformBetweenDoubleRanges(new DoubleRange(a, b), zeroToOne(), yClip);
return c;
}
}
// make the root cell
Cell rootCell() {
Cell c = new Cell();
c.xClip = doubleRange(0, image.getWidth());
c.yClip = doubleRange(0, image.getHeight());
for (int i = 0; i < 3; i++) c.colorClips[i] = doubleRange(0, 255);
return c;
}
}
static int ifloor(double d) {
return (int) Math.floor(d);
}
static float clampZeroToOne(float x) {
return x < 0 ? 0 : x > 1 ? 1 : x;
}
static double clampZeroToOne(double x) {
return x < 0 ? 0 : x > 1 ? 1 : x;
}
static void arrayCopy(Object[] a, Object[] b) {
arraycopy(a, b);
}
static void arrayCopy(Object src, int srcPos, Object dest, int destPos, int n) {
arraycopy(src, srcPos, dest, destPos, n);
}
static Rect toRect_floor(DoubleRect r) {
if (r == null) return null;
int x = ifloor(r.x), y = ifloor(r.y);
return new Rect(x, y, ifloor(r.x2())-x, ifloor(r.y2())-y);
}
static DoubleRect doubleRectFromRanges(DoubleRange x, DoubleRange y) {
return new DoubleRect(x.start, y.start, x.length(), y.length());
}
static double ii_averageBrightnessOfArea(IIntegralImage img, int x1, int y1, int x2, int y2) {
return doubleRatio(integralImage_sumRect(img, x1, y1, x2, y2), (x2-x1)*(y2-y1)*3);
}
static double ii_averageBrightnessOfArea(IIntegralImage img, int x1, int y1, int x2, int y2, int channel) {
return doubleRatio(integralImage_sumRect(img, x1, y1, x2, y2, channel), (x2-x1)*(y2-y1));
}
static double ii_averageBrightnessOfArea(IIntegralImage img, Rect r) {
return ii_averageBrightnessOfArea(img, r.x, r.y, r.x2(), r.y2());
}
static double ii_averageBrightnessOfArea(IIntegralImage img, Rect r, int channel) {
return ii_averageBrightnessOfArea(img, r.x, r.y, r.x2(), r.y2(), channel);
}
static double ii_averageBrightnessOfArea(IntegralImage img, int x1, int y1, int x2, int y2) {
return doubleRatio(integralImage_sumRect(img, x1, y1, x2, y2), (x2-x1)*(y2-y1)*3);
}
static double ii_averageBrightnessOfArea(IntegralImage img, int x1, int y1, int x2, int y2, int channel) {
return doubleRatio(integralImage_sumRect(img, x1, y1, x2, y2, channel), (x2-x1)*(y2-y1));
}
static double ii_averageBrightnessOfArea(IntegralImage img, Rect r) {
return ii_averageBrightnessOfArea(img, r.x, r.y, r.x2(), r.y2());
}
static double ii_averageBrightnessOfArea(IntegralImage img, Rect r, int channel) {
return ii_averageBrightnessOfArea(img, r.x, r.y, r.x2(), r.y2(), channel);
}
static double transformBetweenDoubleRanges(double x, DoubleRange src, DoubleRange dest) {
return dest.start+dest.length()*doubleRatio(x-src.start, src.length());
}
static DoubleRange transformBetweenDoubleRanges(DoubleRange r, DoubleRange src, DoubleRange dest) {
return r == null ? null :
new DoubleRange(transformBetweenDoubleRanges(r.start, src, dest),
transformBetweenDoubleRanges(r.end, src, dest));
}
static DoubleRange zeroToOne_value = new DoubleRange(0, 1);
static DoubleRange zeroToOne() {
return zeroToOne_value;
}
// 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(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 DoubleRange doubleRange(double start, double end) {
return new DoubleRange(start, end);
}
static void arraycopy(Object[] a, Object[] b) {
if (a != null && b != null)
arraycopy(a, 0, b, 0, Math.min(a.length, b.length));
}
static void arraycopy(Object src, int srcPos, Object dest, int destPos, int n) {
if (n != 0)
System.arraycopy(src, srcPos, dest, destPos, n);
}
static double doubleRatio(double x, double y) {
return y == 0 ? 0 : x/y;
}
// one channel
static int integralImage_sumRect(IIntegralImage img, int x1, int y1, int x2, int y2, int channel) {
int bottomLeft = img.getIntegralValue(x1-1, y2-1, channel);
int bottomRight = img.getIntegralValue(x2-1, y2-1, channel);
int topLeft = img.getIntegralValue(x1-1, y1-1, channel);
int topRight = img.getIntegralValue(x2-1, y1-1, channel);
return bottomRight+topLeft-topRight-bottomLeft;
}
// sum all channels. TODO: might exceed int range on huge images
static int integralImage_sumRect(IIntegralImage img, int x1, int y1, int x2, int y2) {
int bottomLeft = img.getIntegralValue(x1-1, y2-1);
int bottomRight = img.getIntegralValue(x2-1, y2-1);
int topLeft = img.getIntegralValue(x1-1, y1-1);
int topRight = img.getIntegralValue(x2-1, y1-1);
return bottomRight+topLeft-topRight-bottomLeft;
}
// one channel
static int integralImage_sumRect(IntegralImage img, int x1, int y1, int x2, int y2, int channel) {
int bottomLeft = img.getIntegralValue(x1-1, y2-1, channel);
int bottomRight = img.getIntegralValue(x2-1, y2-1, channel);
int topLeft = img.getIntegralValue(x1-1, y1-1, channel);
int topRight = img.getIntegralValue(x2-1, y1-1, channel);
return bottomRight+topLeft-topRight-bottomLeft;
}
// sum all channels. TODO: might exceed int range on huge images
static int integralImage_sumRect(IntegralImage img, int x1, int y1, int x2, int y2) {
int bottomLeft = img.getIntegralValue(x1-1, y2-1);
int bottomRight = img.getIntegralValue(x2-1, y2-1);
int topLeft = img.getIntegralValue(x1-1, y1-1);
int topRight = img.getIntegralValue(x2-1, y1-1);
return bottomRight+topLeft-topRight-bottomLeft;
}
static ArrayList emptyList() {
return new ArrayList();
//ret Collections.emptyList();
}
static ArrayList emptyList(int capacity) {
return new ArrayList(max(0, capacity));
}
// Try to match capacity
static ArrayList emptyList(Iterable l) {
return l instanceof Collection ? emptyList(((Collection) l).size()) : emptyList();
}
static ArrayList emptyList(Object[] l) {
return emptyList(l(l));
}
// get correct type at once
static ArrayList emptyList(Class c) {
return new ArrayList();
}
static int max(int a, int b) { return Math.max(a, b); }
static int max(int a, int b, int c) { return max(max(a, b), c); }
static long max(int a, long b) { return Math.max((long) a, b); }
static long max(long a, long b) { return Math.max(a, b); }
static double max(int a, double b) { return Math.max((double) a, b); }
static float max(float a, float b) { return Math.max(a, b); }
static double max(double a, double b) { return Math.max(a, b); }
static int max(Collection c) {
int x = Integer.MIN_VALUE;
for (int i : c) x = max(x, i);
return x;
}
static double max(double[] c) {
if (c.length == 0) return Double.MIN_VALUE;
double x = c[0];
for (int i = 1; i < c.length; i++) x = Math.max(x, c[i]);
return x;
}
static float max(float[] c) {
if (c.length == 0) return Float.MAX_VALUE;
float x = c[0];
for (int i = 1; i < c.length; i++) x = Math.max(x, c[i]);
return x;
}
static byte max(byte[] c) {
byte x = -128;
for (byte d : c) if (d > x) x = d;
return x;
}
static short max(short[] c) {
short x = -0x8000;
for (short d : c) if (d > x) x = d;
return x;
}
static int max(int[] c) {
int x = Integer.MIN_VALUE;
for (int d : c) if (d > x) x = d;
return x;
}
static int l(Object[] a) { return a == null ? 0 : a.length; }
static int l(boolean[] a) { return a == null ? 0 : a.length; }
static int l(byte[] a) { return a == null ? 0 : a.length; }
static int l(short[] a) { return a == null ? 0 : a.length; }
static int l(long[] a) { return a == null ? 0 : a.length; }
static int l(int[] a) { return a == null ? 0 : a.length; }
static int l(float[] a) { return a == null ? 0 : a.length; }
static int l(double[] a) { return a == null ? 0 : a.length; }
static int l(char[] a) { return a == null ? 0 : a.length; }
static int l(Collection c) { return c == null ? 0 : c.size(); }
static int l(Iterator i) { return iteratorCount_int_close(i); } // consumes the iterator && closes it if possible
static int l(Map m) { return m == null ? 0 : m.size(); }
static int l(CharSequence s) { return s == null ? 0 : s.length(); }
static long l(File f) { return f == null ? 0 : f.length(); }
static int l(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 double l(DoubleRange r) { return r == null ? 0 : r.length(); }
static int iteratorCount_int_close(Iterator i) { try {
int n = 0;
if (i != null) while (i.hasNext()) { i.next(); ++n; }
if (i instanceof AutoCloseable) ((AutoCloseable) i).close();
return n;
} catch (Exception __e) { throw rethrow(__e); } }
static Object call(Object o) {
return callF(o);
}
// varargs assignment fixer for a single string array argument
static Object call(Object o, String method, String[] arg) {
return call(o, method, new Object[] {arg});
}
static Object call(Object o, String method, Object... args) {
//ret call_cached(o, method, args);
return call_withVarargs(o, method, args);
}
static RuntimeException rethrow(Throwable t) {
if (t instanceof Error)
_handleError((Error) t);
throw t instanceof RuntimeException ? (RuntimeException) t : new RuntimeException(t);
}
static RuntimeException rethrow(String msg, Throwable t) {
throw new RuntimeException(msg, t);
}
static Map> callF_cache = newDangerousWeakHashMap();
static B callF(F1 f, A a) {
return f == null ? null : f.get(a);
}
static void callF(VF1 f, A a) {
if (f != null) f.get(a);
}
static Object callF(Runnable r) { { if (r != null) r.run(); } return null; }
static Object callF(Object f, Object... args) {
if (f instanceof String)
return callMCWithVarArgs((String) f, args); // possible SLOWDOWN over callMC
return safeCallF(f, args);
}
static Object safeCallF(Object f, Object... args) {
if (f instanceof Runnable) {
((Runnable) f).run();
return null;
}
if (f == null) return null;
Class c = f.getClass();
ArrayList methods;
synchronized(callF_cache) {
methods = callF_cache.get(c);
if (methods == null)
methods = callF_makeCache(c);
}
int n = l(methods);
if (n == 0) {
throw fail("No get method in " + getClassName(c));
}
if (n == 1) return invokeMethod(methods.get(0), f, args);
for (int i = 0; i < n; i++) {
Method m = methods.get(i);
if (call_checkArgs(m, args, false))
return invokeMethod(m, f, args);
}
throw fail("No matching get method in " + getClassName(c));
}
// used internally
static ArrayList callF_makeCache(Class c) {
ArrayList l = new ArrayList();
Class _c = c;
do {
for (Method m : _c.getDeclaredMethods())
if (m.getName().equals("get")) {
makeAccessible(m);
l.add(m);
}
if (!l.isEmpty()) break;
_c = _c.getSuperclass();
} while (_c != null);
callF_cache.put(c, l);
return l;
}
static Object call_withVarargs(Object o, String method, Object... args) { try {
if (o == null) return null;
if (o instanceof Class) {
Class c = (Class) o;
_MethodCache cache = callOpt_getCache(c);
Method me = cache.findStaticMethod(method, args);
if (me != null)
return invokeMethod(me, null, args);
// try varargs
List methods = cache.cache.get(method);
if (methods != null) methodSearch: for (Method m : methods) {
{ if (!(m.isVarArgs())) continue; }
{ if (!(isStaticMethod(m))) continue; }
Object[] newArgs = massageArgsForVarArgsCall(m, args);
if (newArgs != null)
return invokeMethod(m, null, newArgs);
}
throw fail("Method " + c.getName() + "." + method + "(" + joinWithComma(classNames(args)) + ") not found");
} else {
Class c = o.getClass();
_MethodCache cache = callOpt_getCache(c);
Method me = cache.findMethod(method, args);
if (me != null)
return invokeMethod(me, o, args);
// try varargs
List 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 void _handleError(Error e) {
call(javax(), "_handleError", e);
}
static Map newDangerousWeakHashMap() {
return _registerDangerousWeakMap(synchroMap(new WeakHashMap()));
}
// initFunction: voidfunc(Map) - is called initially, and after clearing the map
static Map newDangerousWeakHashMap(Object initFunction) {
return _registerDangerousWeakMap(synchroMap(new WeakHashMap()), initFunction);
}
static Object callMCWithVarArgs(String method, Object... args) {
return call_withVarargs(mc(), method, args);
}
static RuntimeException fail() { throw new RuntimeException("fail"); }
static RuntimeException fail(Throwable e) { throw asRuntimeException(e); }
static RuntimeException fail(Object msg) { throw new RuntimeException(String.valueOf(msg)); }
static RuntimeException fail(Object... objects) { throw new Fail(objects); }
static RuntimeException fail(String msg) { throw new RuntimeException(msg == null ? "" : msg); }
static RuntimeException fail(String msg, Throwable innerException) { throw new RuntimeException(msg, innerException); }
static String getClassName(Object o) {
return o == null ? "null" : o instanceof Class ? ((Class) o).getName() : o.getClass().getName();
}
static Object invokeMethod(Method m, Object o, Object... args) { try {
try {
return m.invoke(o, args);
} catch (InvocationTargetException e) {
throw rethrow(getExceptionCause(e));
} catch (IllegalArgumentException e) {
throw new IllegalArgumentException(e.getMessage() + " - was calling: " + m + ", args: " + joinWithSpace(classNames(args)));
}
} catch (Exception __e) { throw rethrow(__e); } }
static boolean call_checkArgs(Method m, Object[] args, boolean debug) {
Class>[] types = m.getParameterTypes();
if (types.length != args.length) {
if (debug)
print("Bad parameter length: " + args.length + " vs " + types.length);
return false;
}
for (int i = 0; i < types.length; i++) {
Object arg = args[i];
if (!(arg == null ? !types[i].isPrimitive()
: isInstanceX(types[i], arg))) {
if (debug)
print("Bad parameter " + i + ": " + arg + " vs " + types[i]);
return false;
}
}
return true;
}
static Field makeAccessible(Field f) {
try {
f.setAccessible(true);
} catch (Throwable e) {
// Note: The error reporting only works with Java VM option --illegal-access=deny
vmBus_send("makeAccessible_error", e, f);
}
return f;
}
static Method makeAccessible(Method m) {
try {
m.setAccessible(true);
} catch (Throwable e) {
vmBus_send("makeAccessible_error", e, m);
}
return m;
}
static Constructor makeAccessible(Constructor c) {
try {
c.setAccessible(true);
} catch (Throwable e) {
vmBus_send("makeAccessible_error", e, c);
}
return c;
}
static final Map callOpt_cache = newDangerousWeakHashMap();
static Object callOpt_cached(Object o, String methodName, Object... args) { try {
if (o == null) return null;
if (o instanceof Class) {
Class c = (Class) o;
_MethodCache cache = callOpt_getCache(c);
// TODO: (super-rare) case where method exists static and non-static
// with different args
Method me = cache.findMethod(methodName, args);
if (me == null || (me.getModifiers() & Modifier.STATIC) == 0) return null;
return invokeMethod(me, null, args);
} else {
Class c = o.getClass();
_MethodCache cache = callOpt_getCache(c);
Method me = cache.findMethod(methodName, args);
if (me == null) return null;
return invokeMethod(me, o, args);
}
} catch (Exception __e) { throw rethrow(__e); } }
// no longer synchronizes! (see #1102990)
static _MethodCache callOpt_getCache(Class c) {
_MethodCache cache = callOpt_cache.get(c);
if (cache == null)
callOpt_cache.put(c, cache = new _MethodCache(c));
return cache;
}
static boolean isStaticMethod(Method m) {
return methodIsStatic(m);
}
static Object[] massageArgsForVarArgsCall(Method m, Object[] args) {
Class>[] types = m.getParameterTypes();
int n = types.length-1, nArgs = args.length;
if (nArgs < n) return null;
for (int i = 0; i < n; i++)
if (!argumentCompatibleWithType(args[i], types[i]))
return null;
Class varArgType = types[n].getComponentType();
for (int i = n; i < nArgs; i++)
if (!argumentCompatibleWithType(args[i], varArgType))
return null;
Object[] newArgs = new Object[n+1];
arraycopy(args, 0, newArgs, 0, n);
Object[] varArgs = arrayOfType(varArgType, nArgs-n);
arraycopy(args, n, varArgs, 0, nArgs-n);
newArgs[n] = varArgs;
return newArgs;
}
static String joinWithComma(Collection c) {
return join(", ", c);
}
static String joinWithComma(String... c) {
return join(", ", c);
}
static String joinWithComma(Pair p) {
return p == null ? "" : joinWithComma(str(p.a), str(p.b));
}
static List classNames(Collection l) {
return getClassNames(l);
}
static List classNames(Object[] l) {
return getClassNames(Arrays.asList(l));
}
static Class javax() {
return getJavaX();
}
static List _registerDangerousWeakMap_preList;
static A _registerDangerousWeakMap(A map) {
return _registerDangerousWeakMap(map, null);
}
static A _registerDangerousWeakMap(A map, Object init) {
callF(init, map);
if (init instanceof String) {
final String f = (String) init;
init = new VF1