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 java.text.*;
import java.util.TimeZone;
class main {
static LongRange dateStructureToTimestampRange(DateStructures.SomeDate d) { return dateStructureToTimestampRange(d, new DateInterpretationConfig()); }
static LongRange dateStructureToTimestampRange(DateStructures.SomeDate d, DateInterpretationConfig config) {
return new DateStructureToTimestampRange(config).getRange(d);
}
static class DateStructureToTimestampRange {
TimeZone tz;
long now;
boolean assumeFuture = false;
DateStructureToTimestampRange(DateInterpretationConfig config) {
tz = config.timeZone;
now = config.now;
assumeFuture = config.assumeFuture;
}
DateStructures.Year currentYear() {
return new DateStructures.Year(year(now, tz));
}
DateStructures.Month currentMonth() {
return new DateStructures.Month(month(now, tz), currentYear());
}
DateStructures.SomeDate concretizeDate(DateStructures.SomeDate d) {
if (d instanceof DateStructures.CurrentMonthPlus)
d = new DateStructures.Month(month(now, tz) + ((DateStructures.CurrentMonthPlus) d).nMonths, currentYear());
if (d instanceof DateStructures.TodayPlus)
d = new DateStructures.Day(dayOfMonth(now, tz) + ((DateStructures.TodayPlus) d).nDays, currentMonth());
if (d instanceof DateStructures.CurrentYearPlus)
d = new DateStructures.Year(year(now, tz) + ((DateStructures.CurrentYearPlus) d).nYears);
if (d instanceof DateStructures.CurrentWeekPlus)
d = new DateStructures.Week(weekInYear(now, tz) + ((DateStructures.CurrentWeekPlus) d).nWeeks, currentYear());
return d;
}
LongRange getRange(DateStructures.SomeDate d) {
d = concretizeDate(d);
// year
if (d instanceof DateStructures.Year)
return longRange(yearToTimestamp(((DateStructures.Year) d).year, tz), yearToTimestamp(((DateStructures.Year) d).year+1, tz));
// month
if (d instanceof DateStructures.Month) {
if (((DateStructures.Month) d).year == null)
((DateStructures.Month) d).year = (DateStructures.Year) concretizeDate(new DateStructures.CurrentYearPlus(((DateStructures.Month) d).month < currentMonth().month ? 1 : 0));
int year = ((DateStructures.Month) d).year.year;
return longRange(
yearAndMonthToTimestamp(year, ((DateStructures.Month) d).month, tz),
yearAndMonthToTimestamp(year, ((DateStructures.Month) d).month+1, tz));
}
// week
if (d instanceof DateStructures.Week) {
int year = ((DateStructures.Week) d).year.year;
return longRange(
yearAndWeekToTimestamp(year, ((DateStructures.Week) d).week, tz),
yearAndWeekToTimestamp(year, ((DateStructures.Week) d).week+1, tz));
}
if (d instanceof DateStructures.Weekday) {
if (((DateStructures.Weekday) d).week == null) ((DateStructures.Weekday) d).week = (DateStructures.Week) concretizeDate(new DateStructures.CurrentWeekPlus(((DateStructures.Weekday) d).weekday < dayOfWeek_nr(now, tz) ? 1 : 0));
long start = getRange(((DateStructures.Weekday) d).week).start+(((DateStructures.Weekday) d).weekday-1)*24*60*60*1000;
return new LongRange(start, start+24*60*60*1000);
}
// day
if (d instanceof DateStructures.Day) {
int month = ((DateStructures.Day) d).month.month;
int year = ((DateStructures.Day) d).month.year.year;
return longRange(
ymdToTimestamp(year, month, ((DateStructures.Day) d).day, tz),
ymdToTimestamp(year, month, ((DateStructures.Day) d).day+1, tz));
}
// hour
if (d instanceof DateStructures.Hour) {
if (((DateStructures.Hour) d).isPM == null) throw fail("AM/PM unknown: " + ((DateStructures.Hour) d));
long dayStart = getRange(assertNotNull("day of hour", ((DateStructures.Hour) d).day)).start;
int actualHour = ((DateStructures.Hour) d).hour+(((DateStructures.Hour) d).isPM ? 12 : 0);
return longRange(dayStart+hoursToMS(actualHour), dayStart+hoursToMS(actualHour+1));
}
// between
if (d instanceof DateStructures.Between) {
return longRange(getRange(((DateStructures.Between) d).from).start, getRange(((DateStructures.Between) d).to).start);
}
throw fail("dateStructureToTimestampRange: unknown type " + d);
}
}
static int year() {
return localYear();
}
static int year(long now) {
return localYear(now);
}
static int year(long now, TimeZone tz) {
return parseInt(simpleDateFormat("y", tz).format(now));
}
static int month() {
return localMonth();
}
static int month(long now) {
return localMonth(now);
}
static int month(long now, TimeZone tz) {
return parseInt(simpleDateFormat("M", tz).format(now));
}
static int dayOfMonth() {
return localDayOfMonth();
}
static int dayOfMonth(long now) {
return localDayOfMonth(now);
}
static int dayOfMonth(long now, TimeZone tz) {
return parseInt(simpleDateFormat("d", tz).format(now));
}
static int weekInYear(long time, TimeZone tz) {
return parseInt(simpleDateFormat("w", tz).format(time));
}
static LongRange longRange(long start, long end) {
return new LongRange(start, end);
}
static long yearToTimestamp(int year, TimeZone tz) { try {
return simpleDateFormat("y", tz).parse(str(year)).getTime();
} catch (Exception __e) { throw rethrow(__e); } }
static long yearAndMonthToTimestamp(int year, int month, TimeZone tz) { try {
return simpleDateFormat("y/M", tz).parse(year + "/" + month).getTime();
} catch (Exception __e) { throw rethrow(__e); } }
static long yearAndWeekToTimestamp(int year, int week, TimeZone tz) { try {
return simpleDateFormat("y/w", tz).parse(year + "/" + week).getTime();
} catch (Exception __e) { throw rethrow(__e); } }
static int dayOfWeek_nr() {
return dayOfWeek_nr(java.util.Calendar.getInstance());
}
static int dayOfWeek_nr(java.util.Calendar calendar) {
return calendar.get(java.util.Calendar.DAY_OF_WEEK);
}
static int dayOfWeek_nr(long time) {
return dayOfWeek_nr(calendarFromTime(time));
}
static int dayOfWeek_nr(long time, TimeZone tz) {
return dayOfWeek_nr(calendarFromTime(time, tz));
}
static long ymdToTimestamp(int year, int month, int day, TimeZone tz) { try {
return simpleDateFormat("y/M/d", tz).parse(year + "/" + month + "/" + day).getTime();
} catch (Exception __e) { throw rethrow(__e); } }
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(String msg) { throw new RuntimeException(msg == null ? "" : msg); }
static RuntimeException fail(String msg, Throwable innerException) { throw new RuntimeException(msg, innerException); }
static A assertNotNull(A a) {
assertTrue(a != null);
return a;
}
static A assertNotNull(String msg, A a) {
assertTrue(msg, a != null);
return a;
}
static long hoursToMS(double hours) {
return round(hours*60*60*1000);
}
static int localYear() {
return localYear(now());
}
static int localYear(long time) {
return parseInt(simpleDateFormat_local("yyyy").format(time));
}
static int parseInt(String s) {
return emptyString(s) ? 0 : Integer.parseInt(s);
}
static int parseInt(char c) {
return Integer.parseInt(str(c));
}
static java.text.SimpleDateFormat simpleDateFormat(String format, TimeZone timeZone) {
java.text.SimpleDateFormat sdf = new java.text.SimpleDateFormat(format);
sdf.setTimeZone(timeZone);
return sdf;
}
static int localMonth(long time) {
return parseInt(simpleDateFormat_local("MM").format(time));
}
static int localMonth() {
return localMonth(now());
}
static int localDayOfMonth(long time) {
return parseInt(simpleDateFormat_local("dd").format(time));
}
static int localDayOfMonth() {
return localDayOfMonth(now());
}
static String str(Object o) {
return o == null ? "null" : o.toString();
}
static String str(char[] c) {
return new String(c);
}
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 java.util.Calendar calendarFromTime(long time, TimeZone tz) {
java.util.Calendar c = java.util.Calendar.getInstance(tz);
c.setTimeInMillis(time);
return c;
}
static java.util.Calendar calendarFromTime(long time) {
java.util.Calendar c = java.util.Calendar.getInstance();
c.setTimeInMillis(time);
return c;
}
static RuntimeException asRuntimeException(Throwable t) {
if (t instanceof Error)
_handleError((Error) t);
return t instanceof RuntimeException ? (RuntimeException) t : new RuntimeException(t);
}
static void assertTrue(Object o) {
if (!(eq(o, true) /*|| isTrue(pcallF(o))*/))
throw fail(str(o));
}
static boolean assertTrue(String msg, boolean b) {
if (!b)
throw fail(msg);
return b;
}
static boolean assertTrue(boolean b) {
if (!b)
throw fail("oops");
return b;
}
static long round(double d) {
return Math.round(d);
}
static long now_virtualTime;
static long now() {
return now_virtualTime != 0 ? now_virtualTime : System.currentTimeMillis();
}
static SimpleDateFormat simpleDateFormat_local(String format) {
SimpleDateFormat sdf = new SimpleDateFormat(format);
sdf.setTimeZone(localTimeZone());
return sdf;
}
static boolean emptyString(String s) {
return s == null || s.length() == 0;
}
static void _handleError(Error e) {
call(javax(), "_handleError", e);
}
static boolean eq(Object a, Object b) {
return a == b || a != null && b != null && a.equals(b);
}
static TimeZone localTimeZone() {
return getTimeZone(standardTimeZone());
// TimeZone.getDefault()?
}
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 Class javax() {
return getJavaX();
}
static TimeZone getTimeZone(String name) {
return TimeZone.getTimeZone(name);
}
static String standardTimeZone_name = "Europe/Berlin";
static String standardTimeZone() {
return standardTimeZone_name;
}
static Map> callF_cache = newDangerousWeakHashMap();
static B callF(F1 f, A a) {
return f == null ? null : f.get(a);
}
static B callF(IF1 f, A a) {
return f == null ? null : f.get(a);
}
static C callF(IF2 f, A a, B b) {
return f == null ? null : f.get(a, b);
}
static void callF(VF1 f, A a) {
if (f != null) f.get(a);
}
static Object callF(Object f, Object... args) { try {
if (f instanceof String)
return callMCWithVarArgs((String) f, args); // possible SLOWDOWN over callMC
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));
} catch (Exception __e) { throw rethrow(__e); } }
// 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 Class __javax;
static Class getJavaX() { try {
return __javax;
} catch (Exception __e) { throw rethrow(__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 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 long l(LongRange r) { return r == null ? 0 : r.length(); }
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); } }
static _MethodCache callOpt_getCache(Class c) {
synchronized(callOpt_cache) {
_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 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