[21902 ms] 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.*;

class main {

static Map<Thread, Boolean> _registerThread_threads = newWeakHashMap();

static Thread _registerThread(Thread t) {

  _registerThread_threads.put(t, true);

  return t;

}

static void _registerThread() { _registerThread(Thread.currentThread()); }

static Pair<String, List<String>> tok_parseFunctionCall(String s) {

  return tok_parseFunctionCall(javaTok(s));

}

static Pair<String, List<String>> tok_parseFunctionCall(List<String> tok) {

  if (!(isIdentifier(get(tok, 1)) && eqGet(tok, 3, "("))) return null;

  Map<Integer, Integer> bracketMap = getBracketMap(tok);

  if (neq(bracketMap.get(3), l(tok)-2)) return null;

  int i = 5, argStart = 5;

  List<String> args = new ArrayList();

  while (i < l(tok)-2) {

    Integer j = bracketMap.get(i);

    if (j != null) { i = j+2; continue; }

    if (eqGetOneOf(tok, i, ",")) {

      if (i > argStart) args.add(trimJoinSubList(tok, argStart, i));

      argStart = i+2;

    }

    i += 2;

  }

  if (i > argStart) args.add(trimJoinSubList(tok, argStart, i));

  return pair(tok.get(1), args);

}

static boolean isIdentifier(String s) {

  return isJavaIdentifier(s);

}

// map: index of opening bracket -> index of closing bracket

static Map<Integer, Integer> getBracketMap(List tok) {

  TreeMap<Integer,Integer> map = new TreeMap();

  List<Integer> stack = new ArrayList();

  for (int i = 1; i < l(tok); i+= 2) {

    if (getBracketMap_opening.contains(tok.get(i)))

      stack.add(i);

    else if (getBracketMap_closing.contains(tok.get(i))) {

      if (!empty(stack))

        map.put(liftLast(stack), i);

    }

  }

  return map;

}

static List<String> getBracketMap_opening = ll("{", "(");

static List<String> getBracketMap_closing = ll("}", ")");

static <A> boolean eqGetOneOf(List<A> l, int i, A... options) {

  return eqOneOf(get(l, i), options);

}

// replacement for class JavaTok

// maybe incomplete, might want to add floating point numbers

// todo also: extended multi-line strings

static int javaTok_n, javaTok_elements;

static boolean javaTok_opt;

static List<String> javaTok(String s) {

  return javaTok(s, null);

}

static List<String> javaTok(String s, List<String> existing) {

  ++javaTok_n;

  int nExisting = javaTok_opt && existing != null ? existing.size() : 0;

  ArrayList<String> tok = existing != null ? new ArrayList(nExisting) : new ArrayList();

  int l = s.length();

  int i = 0, n = 0;

  while (i < l) {

    int j = i;

    char c, d;

    // scan for whitespace

    while (j < l) {

      c = s.charAt(j);

      d = j+1 >= l ? '\0' : s.charAt(j+1);

      if (c == ' ' || c == '\t' || c == '\r' || c == '\n')

        ++j;

      else if (c == '/' && d == '*') {

        do ++j; while (j < l && !s.substring(j, Math.min(j+2, l)).equals("*/"));

        j = Math.min(j+2, l);

      } else if (c == '/' && d == '/') {

        do ++j; while (j < l && "\r\n".indexOf(s.charAt(j)) < 0);

      } else

        break;

    }

    if (n < nExisting && javaTok_isCopyable(existing.get(n), s, i, j))

      tok.add(existing.get(n));

    else

      tok.add(javaTok_substringN(s, i, j));

    ++n;

    i = j;

    if (i >= l) break;

    c = s.charAt(i);

    d = i+1 >= l ? '\0' : s.charAt(i+1);

    // scan for non-whitespace

    // Special JavaX syntax: 'identifier

    if (c == '\'' && Character.isJavaIdentifierStart(d) && i+2 < l && "'\\".indexOf(s.charAt(i+2)) < 0) {

      j += 2;

      while (j < l && Character.isJavaIdentifierPart(s.charAt(j)))

        ++j;

    } else if (c == '\'' || c == '"') {

      char opener = c;

      ++j;

      while (j < l) {

        if (s.charAt(j) == opener /*|| s.charAt(j) == '\n'*/) { // allow multi-line strings

          ++j;

          break;

        } else if (s.charAt(j) == '\\' && j+1 < l)

          j += 2;

        else

          ++j;

      }

    } else if (Character.isJavaIdentifierStart(c))

      do ++j; while (j < l && (Character.isJavaIdentifierPart(s.charAt(j)) || "'".indexOf(s.charAt(j)) >= 0)); // for stuff like "don't"

    else if (Character.isDigit(c)) {

      do ++j; while (j < l && Character.isDigit(s.charAt(j)));

      if (j < l && s.charAt(j) == 'L') ++j; // Long constants like 1L

    } else if (c == '[' && d == '[') {

      do ++j; while (j+1 < l && !s.substring(j, j+2).equals("]]"));

      j = Math.min(j+2, l);

    } else if (c == '[' && d == '=' && 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

      ++j;

    if (n < nExisting && javaTok_isCopyable(existing.get(n), s, i, j))

      tok.add(existing.get(n));

    else

      tok.add(javaTok_substringC(s, i, j));

    ++n;

    i = j;

  }

  if ((tok.size() % 2) == 0) tok.add("");

  javaTok_elements += tok.size();

  return tok;

}

static List<String> javaTok(List<String> tok) {

  return javaTok(join(tok), tok);

}

static boolean javaTok_isCopyable(String t, String s, int i, int j) {

  return t.length() == j-i

    && s.regionMatches(i, t, 0, j-i); // << could be left out, but that's brave

}

static boolean eqGet(List l, int i, Object o) {

  return eq(get(l, i), o);

}

static <A, B> Map<A, B> newWeakHashMap() {

  return _registerWeakMap(synchroMap(new WeakHashMap()));

}

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(int[] a) { return a == null ? 0 : a.length; }

static int l(float[] 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(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 instanceof String ? l((String) o)

    : o instanceof Map ? l((Map) o)

    : l((Collection) o); // incomplete

}

static <A, B> Pair<A, B> pair(A a, B b) {

  return new Pair(a, b);

}

static <A> Pair<A, A> pair(A a) {

  return new Pair(a, a);

}

// get purpose 1: access a list/array/map (safer version of x.get(y))

static <A> A get(List<A> l, int idx) {

  return l != null && idx >= 0 && idx < l(l) ? l.get(idx) : null;

}

// seems to conflict with other signatures

/*static <A, B> B get(Map<A, B> map, A key) {

  ret map != null ? map.get(key) : null;

}*/

static <A> A get(A[] l, int idx) {

  return idx >= 0 && idx < l(l) ? l[idx] : null;

}

// default to false

static boolean get(boolean[] l, int idx) {

  return idx >= 0 && idx < l(l) ? l[idx] : false;

}

// get purpose 2: access a field by reflection or a map

static Object get(Object o, String field) {

  try {

    if (o instanceof Class) return get((Class) o, field);

    if (o instanceof Map)

      return ((Map) o).get(field);

    Field f = getOpt_findField(o.getClass(), field);

    if (f != null) {

      f.setAccessible(true);

      return f.get(o);

    }

  } catch (Exception e) {

    throw asRuntimeException(e);

  }

  throw new RuntimeException("Field '" + field + "' not found in " + o.getClass().getName());

}

static Object get_raw(Object o, String field) {

  try {

    Field f = get_findField(o.getClass(), field);

    f.setAccessible(true);

    return f.get(o);

  } catch (Exception e) {

    throw new RuntimeException(e);

  }

}

static Object get(Class c, String field) {

  try {

    Field f = get_findStaticField(c, field);

    f.setAccessible(true);

    return f.get(null);

  } catch (Exception e) {

    throw new RuntimeException(e);

  }

}

static Field get_findStaticField(Class<?> c, String field) {

  Class _c = c;

  do {

    for (Field f : _c.getDeclaredFields())

      if (f.getName().equals(field) && (f.getModifiers() & java.lang.reflect.Modifier.STATIC) != 0)

        return f;

    _c = _c.getSuperclass();

  } while (_c != null);

  throw new RuntimeException("Static field '" + field + "' not found in " + c.getName());

}

static Field get_findField(Class<?> c, String field) {

  Class _c = c;

  do {

    for (Field f : _c.getDeclaredFields())

      if (f.getName().equals(field))

        return f;

    _c = _c.getSuperclass();

  } while (_c != null);

  throw new RuntimeException("Field '" + field + "' not found in " + c.getName());

}

static boolean neq(Object a, Object b) {

  return !eq(a, b);

}

static String trimJoinSubList(List<String> l, int i, int j) {

  return trim(join(subList(l, i, j)));

}

static String trimJoinSubList(List<String> l, int i) {

  return trim(join(subList(l, i)));

}

static <A> List<A> ll(A... a) {

  ArrayList l = new ArrayList(a.length);

  for (A x : a) l.add(x);

  return l;

}

static Map synchroMap() {

  return synchroHashMap();

}

static <A, B> Map<A, B> synchroMap(Map<A, B> map) {

  return Collections.synchronizedMap(map);

}

static <A> A liftLast(List<A> l) {

  if (l.isEmpty()) return null;

  int i = l(l)-1;

  A a = l.get(i);

  l.remove(i);

  return a;

}

static String javaTok_substringC(String s, int i, int j) {

  return s.substring(i, j);

}

static String javaTok_substringN(String s, int i, int j) {

  if (i == j) return "";

  if (j == i+1 && s.charAt(i) == ' ') return " ";

  return s.substring(i, j);

}

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

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

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

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

static boolean empty(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 == null) return true;

  throw fail("unknown type for 'empty': " + getType(o));

}

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

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

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

static RuntimeException asRuntimeException(Throwable t) {

  if (t instanceof Error)

    _handleError((Error) t);

  return t instanceof RuntimeException ? (RuntimeException) t : new RuntimeException(t);

}

static String trim(String s) { return s == null ? null : s.trim(); }

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

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

public static String join(String glue, Iterable<String> strings) {

  if (strings == null) return "";

  StringBuilder buf = new StringBuilder();

  Iterator<String> i = strings.iterator();

  if (i.hasNext()) {

    buf.append(i.next());

    while (i.hasNext())

      buf.append(glue).append(i.next());

  }

  return buf.toString();

}

public static String join(String glue, String... strings) {

  return join(glue, Arrays.asList(strings));

}

static String join(Iterable<String> strings) {

  return join("", strings);

}

static String join(Iterable<String> strings, String glue) {

  return join(glue, strings);

}

public static String join(String[] strings) {

  return join("", strings);

}

static String join(String glue, Pair p) {

  return p == null ? "" : str(p.a) + glue + str(p.b);

}

static <A> List<A> subList(List<A> l, int startIndex) {

  return subList(l, startIndex, l(l));

}

static <A> List<A> subList(List<A> l, int startIndex, int endIndex) {

  startIndex = max(0, min(l(l), startIndex));

  endIndex = max(0, min(l(l), endIndex));

  if (startIndex > endIndex) return litlist();

  return l.subList(startIndex, endIndex);

}

static boolean eqOneOf(Object o, Object... l) {

  for (Object x : l) if (eq(o, x)) return true; return false;

}

static boolean eq(Object a, Object b) {

  return a == null ? b == null : a == b || a.equals(b);

}

// a little kludge for stuff like eq(symbol, "$X")

static List _registerWeakMap_preList;

static <A> A _registerWeakMap(A map) {

  if (javax() == null) {

    // We're in class init

    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 void _onLoad_registerWeakMap() {

  assertNotNull(javax());

  if (_registerWeakMap_preList == null) return;

  for (Object o : _registerWeakMap_preList)

    _registerWeakMap(o);

  _registerWeakMap_preList = null;

}

static Field getOpt_findField(Class<?> c, String field) {

  Class _c = c;

  do {

    for (Field f : _c.getDeclaredFields())

      if (f.getName().equals(field))

        return f;

    _c = _c.getSuperclass();

  } while (_c != null);

  return null;

}

static boolean isJavaIdentifier(String s) {

  if (empty(s) || !Character.isJavaIdentifierStart(s.charAt(0)))

    return false;

  for (int i = 1; i < s.length(); i++)

    if (!Character.isJavaIdentifierPart(s.charAt(i)))

      return false;

  return true;

}

static AtomicLong _handleError_nonVMErrors = new AtomicLong();

static AtomicLong _handleError_vmErrors = new AtomicLong();

static AtomicLong _handleError_outOfMemoryErrors = new AtomicLong();

static volatile long _handleError_lastOutOfMemoryError;

static volatile Error _handleError_lastHardError;

static void _handleError(Error e) {

  if (!(e instanceof VirtualMachineError)) {

    incAtomicLong(_handleError_nonVMErrors);

    return;

  }

  print("\nHARD ERROR\n");

  printStackTrace2(e);

  print("\nHARD ERROR\n");

  _handleError_lastHardError = e;

  incAtomicLong(_handleError_vmErrors);

  if (e instanceof OutOfMemoryError) {

    incAtomicLong(_handleError_outOfMemoryErrors);

    _handleError_lastOutOfMemoryError = sysNow();

  }

}

static int min(int a, int b) {

  return Math.min(a, b);

}

static long min(long a, long b) {

  return Math.min(a, b);

}

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

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

static double min(double a, double b) {

  return Math.min(a, b);

}

static double min(double[] c) {

  double x = Double.MAX_VALUE;

  for (double d : c) x = Math.min(x, d);

  return x;

}

static float min(float[] c) {

  float x = Float.MAX_VALUE;

  for (float d : c) x = Math.min(x, d);

  return x;

}

static byte min(byte[] c) {

  byte x = 127;

  for (byte d : c) if (d < x) x = d;

  return x;

}

static short min(short[] c) {

  short x = 0x7FFF;

  for (short d : c) if (d < x) x = d;

  return x;

}

static Class javax() {

  return getJavaX();

}

static <A> ArrayList<A> litlist(A... a) {

  ArrayList l = new ArrayList(a.length);

  for (A x : a) l.add(x);

  return l;

}

static <A> A assertNotNull(A a) {

  assertTrue(a != null);

  return a;

}

static <A> A assertNotNull(String msg, A a) {

  assertTrue(msg, a != null);

  return a;

}

static <A> List<A> synchroList() {

  return Collections.synchronizedList(new ArrayList<A>());

}

static <A> List<A> synchroList(List<A> l) {

  return Collections.synchronizedList(l);

}

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

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

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

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

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

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

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

static int max(Collection<Integer> c) {

  int x = Integer.MIN_VALUE;

  for (int i : c) x = max(x, i);

  return x;

}

static double max(double[] c) {

  if (c.length == 0) return Double.MIN_VALUE;

  double x = c[0];

  for (int i = 1; i < c.length; i++) x = Math.max(x, c[i]);

  return x;

}

static float max(float[] c) {

  if (c.length == 0) return Float.MAX_VALUE;

  float x = c[0];

  for (int i = 1; i < c.length; i++) x = Math.max(x, c[i]);

  return x;

}

static byte max(byte[] c) {

  byte x = -128;

  for (byte d : c) if (d > x) x = d;

  return x;

}

static short max(short[] c) {

  short x = -0x8000;

  for (short d : c) if (d > x) x = d;

  return x;

}

static void printException(Throwable e) {

  printStackTrace(e);

}

static String str(Object o) {

  return o == null ? "null" : o.toString();

}

static String str(char[] c) {

  return new String(c);

}

static Object call(Object o) {

  return callFunction(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) {

  try {

    if (o instanceof Class) {

      Method m = call_findStaticMethod((Class) o, method, args, false);

      m.setAccessible(true);

      return m.invoke(null, args);

    } else {

      Method m = call_findMethod(o, method, args, false);

      m.setAccessible(true);

      return m.invoke(o, args);

    }

  } catch (Exception e) {

    throw e instanceof RuntimeException ? (RuntimeException) e : new RuntimeException(e);

  }

}

static Method call_findStaticMethod(Class c, String method, Object[] args, boolean debug) {

  Class _c = c;

  while (c != null) {

    for (Method m : c.getDeclaredMethods()) {

      if (debug)

        System.out.println("Checking method " + m.getName() + " with " + m.getParameterTypes().length + " parameters");;

      if (!m.getName().equals(method)) {

        if (debug) System.out.println("Method name mismatch: " + method);

        continue;

      }

      if ((m.getModifiers() & java.lang.reflect.Modifier.STATIC) == 0 || !call_checkArgs(m, args, debug))

        continue;

      return m;

    }

    c = c.getSuperclass();

  }

  throw new RuntimeException("Method '" + method + "' (static) with " + args.length + " parameter(s) not found in " + _c.getName());

}

static Method call_findMethod(Object o, String method, Object[] args, boolean debug) {

  Class c = o.getClass();

  while (c != null) {

    for (Method m : c.getDeclaredMethods()) {

      if (debug)

        System.out.println("Checking method " + m.getName() + " with " + m.getParameterTypes().length + " parameters");;

      if (m.getName().equals(method) && call_checkArgs(m, args, debug))

        return m;

    }

    c = c.getSuperclass();

  }

  throw new RuntimeException("Method '" + method + "' (non-static) with " + args.length + " parameter(s) not found in " + o.getClass().getName());

}

private static boolean call_checkArgs(Method m, Object[] args, boolean debug) {

  Class<?>[] types = m.getParameterTypes();

  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 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 volatile StringBuffer local_log = new StringBuffer(); // not redirected

static volatile StringBuffer print_log = local_log; // might be redirected, e.g. to main bot

// in bytes - will cut to half that

static volatile int print_log_max = 1024*1024;

static volatile int local_log_max = 100*1024;

//static int print_maxLineLength = 0; // 0 = unset

static boolean print_silent; // total mute if set

static Object print_byThread_lock = new Object();

static volatile ThreadLocal<Object> print_byThread; // special handling by thread - prefers F1<S, Bool>

static void print() {

  print("");

}

// slightly overblown signature to return original object...

static <A> A print(A o) {

  ping();

  if (print_silent) return o;

  String s = String.valueOf(o) + "\n";

  print_noNewLine(s);

  return o;

}

static void print_noNewLine(String s) {

  if (print_byThread != null) {

    Object f = print_byThread.get();

    if (f != null)

      if (isFalse(f instanceof F1 ? ((F1) f).get(s) : callF(f, s))) return;

  }

  print_raw(s);

}

static void print_raw(String s) {

  s = fixNewLines(s);

  // TODO if (print_maxLineLength != 0)

  StringBuffer loc = local_log;

  StringBuffer buf = print_log;

  int loc_max = print_log_max;

  if (buf != loc && buf != null) {

    print_append(buf, s, print_log_max);

    loc_max = local_log_max;

  }

  if (loc != null) 

    print_append(loc, s, loc_max);

  System.out.print(s);

}

static void print(long l) {

  print(String.valueOf(l));

}

static void print(char c) {

  print(String.valueOf(c));

}

static void print_append(StringBuffer buf, String s, int max) {

  synchronized(buf) {

    buf.append(s);

    max /= 2;

    if (buf.length() > max) try {

      int newLength = max/2;

      int ofs = buf.length()-newLength;

      String newString = buf.substring(ofs);

      buf.setLength(0);

      buf.append("[...] ").append(newString);

    } catch (Exception e) {

      buf.setLength(0);

    }

  }

}

static String getType(Object o) {

  return getClassName(o);

}

static Map synchroHashMap() {

  return Collections.synchronizedMap(new HashMap());

}

static WeakHashMap<Class, ArrayList<Method>> callF_cache = new WeakHashMap();

  static <A, B> B callF(F1<A, B> f, A a) {

    return f == null ? null : f.get(a);

  }

static Object callF(Object f, Object... args) { try {

  if (f instanceof String)

    return callMC((String) f, args);

  if (f instanceof Runnable) {

    ((Runnable) f).run();

    return null;

  }

  if (f == null) return null;

  Class c = f.getClass();

  ArrayList<Method> methods;

  synchronized(callF_cache) {

    methods = callF_cache.get(c);

    if (methods == null)

      methods = callF_makeCache(c);

  }

  int n = l(methods);

  if (n == 0) throw fail("No get method in " + getClassName(c));

  if (n == 1) return methods.get(0).invoke(f, args);

  for (int i = 0; i < n; i++) {

    Method m = methods.get(i);

    if (call_checkArgs(m, args, false))

      return m.invoke(f, args);

  }

  throw fail("No matching get method in " + getClassName(c));

} catch (Exception __e) { throw rethrow(__e); } }

// used internally

static ArrayList<Method> callF_makeCache(Class c) {

  ArrayList<Method> l = new ArrayList();

  Class _c = c;

  do {

    for (Method m : _c.getDeclaredMethods())

      if (m.getName().equals("get")) {

        m.setAccessible(true);

        l.add(m);

      }

    if (!l.isEmpty()) break;

    _c = _c.getSuperclass();

  } while (_c != null);

  callF_cache.put(c, l);

  return l;

}

static Object callFunction(Object f, Object... args) {

  return callF(f, args);

}

// extended over Class.isInstance() to handle primitive types

static boolean isInstanceX(Class type, Object arg) {

  if (type == boolean.class) return arg instanceof Boolean;

  if (type == int.class) return arg instanceof Integer;

  if (type == long.class) return arg instanceof Long;

  if (type == float.class) return arg instanceof Float;

  if (type == short.class) return arg instanceof Short;

  if (type == char.class) return arg instanceof Character;

  if (type == byte.class) return arg instanceof Byte;

  if (type == double.class) return arg instanceof Double;

  return type.isInstance(arg);

}

static Throwable printStackTrace(Throwable e) {

  // we go to system.out now - system.err is nonsense

  print(getStackTrace(e));

  return e;

}

static void printStackTrace() {

  printStackTrace(new Throwable());

}

static void printStackTrace(String msg) {

  printStackTrace(new Throwable(msg));

}

/*static void printStackTrace(S indent, Throwable e) {

  if (endsWithLetter(indent)) indent += " ";

  printIndent(indent, getStackTrace(e));

}*/

static boolean isFalse(Object o) {

  return eq(false, o);

}

static String getClassName(Object o) {

  return o == null ? "null" : o instanceof Class ? ((Class) o).getName() : o.getClass().getName();

}

static String fixNewLines(String s) {

  return s.replace("\r\n", "\n").replace("\r", "\n");

}

static volatile boolean ping_pauseAll;

static int ping_sleep = 100; // poll pauseAll flag every 100

static volatile boolean ping_anyActions;

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

// always returns true

static boolean ping() {

  if (ping_pauseAll  || ping_anyActions ) ping_impl();

  return true;

}

// returns true when it slept

static boolean ping_impl() { try {

  if (ping_pauseAll && !isAWTThread()) {

    do

      Thread.sleep(ping_sleep);

    while (ping_pauseAll);

    return true;

  }

  if (ping_anyActions) {

    Object action;

    synchronized(ping_actions) {

      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 long sysNow() {

  return System.nanoTime()/1000000;

}

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 void incAtomicLong(AtomicLong l) {

  l.incrementAndGet();

}

static Class __javax;

static Class getJavaX() {

  return __javax;

}

static Throwable printStackTrace2(Throwable e) {

  // we go to system.out now - system.err is nonsense

  print(getStackTrace2(e));

  return e;

}

static void printStackTrace2() {

  printStackTrace2(new Throwable());

}

static void printStackTrace2(String msg) {

  printStackTrace2(new Throwable(msg));

}

/*static void printStackTrace2(S indent, Throwable e) {

  if (endsWithLetter(indent)) indent += " ";

  printIndent(indent, getStackTrace2(e));

}*/

static HashMap<String, List<Method>> callMC_cache = new HashMap();

static String callMC_key;

static Method callMC_value;

// varargs assignment fixer for a single string array argument

static Object callMC(String method, String[] arg) {

  return callMC(method, new Object[] {arg});

}

static Object callMC(String method, Object... args) { try {

  Method me;

  if (callMC_cache == null) callMC_cache = new HashMap(); // initializer time workaround

  synchronized(callMC_cache) {

    me = method == callMC_key ? callMC_value : null;

  }

  if (me != null) try {

    return me.invoke(null, args);

  } catch (IllegalArgumentException e) {

    throw new RuntimeException("Can't call " + me + " with arguments " + classNames(args), e);

  }

  List<Method> m;

  synchronized(callMC_cache) {

    m = callMC_cache.get(method);

  }

  if (m == null) {

    if (callMC_cache.isEmpty()) {

      callMC_makeCache();

      m = callMC_cache.get(method);

    }

    if (m == null) throw fail("Method named " + method + " not found in main");

  }

  int n = m.size();

  if (n == 1) {

    me = m.get(0);

    synchronized(callMC_cache) {

      callMC_key = method;

      callMC_value = me;

    }

    try {

      return me.invoke(null, args);

    } catch (IllegalArgumentException e) {

      throw new RuntimeException("Can't call " + me + " with arguments " + classNames(args), e);

    }

  }

  for (int i = 0; i < n; i++) {

    me = m.get(i);

    if (call_checkArgs(me, args, false))

      return me.invoke(null, args);

  }

  throw fail("No method called " + method + " with matching arguments found in main");

} catch (Exception __e) { throw rethrow(__e); } }

static void callMC_makeCache() {

  synchronized(callMC_cache) {

    callMC_cache.clear();

    Class _c = (Class) mc(), c = _c;

    while (c != null) {

      for (Method m : c.getDeclaredMethods())

        if ((m.getModifiers() & java.lang.reflect.Modifier.STATIC) != 0) {

          m.setAccessible(true);

          multiMapPut(callMC_cache, m.getName(), m);

        }

      c = c.getSuperclass();

    }

  }

}

static String getStackTrace(Throwable throwable) {

  lastException(throwable);

  return getStackTrace_noRecord(throwable);

}

static String getStackTrace_noRecord(Throwable throwable) {

  StringWriter writer = new StringWriter();

  throwable.printStackTrace(new PrintWriter(writer));

  return hideCredentials(writer.toString());

}

static String getStackTrace() {

  return getStackTrace_noRecord(new Throwable());

}

// TODO: test if android complains about this

static boolean isAWTThread() {

  if (isAndroid()) return false;

  if (isHeadless()) return false;

  return isAWTThread_awt();

}

static boolean isAWTThread_awt() {

  return SwingUtilities.isEventDispatchThread();

}

static String getStackTrace2(Throwable throwable) {

  return hideCredentials(getStackTrace(throwable) + replacePrefix("java.lang.RuntimeException: ", "FAIL: ",

    hideCredentials(str(getInnerException(throwable)))) + "\n");

}

static Thread currentThread() {

  return Thread.currentThread();

}

static RuntimeException rethrow(Throwable e) {

  throw asRuntimeException(e);

}

static volatile Throwable lastException_lastException;

static Throwable lastException() {

  return lastException_lastException;

}

static void lastException(Throwable e) {

  lastException_lastException = e;

}

static Boolean isHeadless_cache;

static boolean isHeadless() {

  if (isHeadless_cache != null) return isHeadless_cache;

  if (GraphicsEnvironment.isHeadless()) return isHeadless_cache = true;

  // Also check if AWT actually works.

  // If DISPLAY variable is set but no X server up, this will notice.

  try {

    SwingUtilities.isEventDispatchThread();

    return isHeadless_cache = false;

  } catch (Throwable e) { return isHeadless_cache = true; }

}

static List<String> classNames(Collection l) {

  return getClassNames(l);

}

static List<String> classNames(Object[] l) {

  return getClassNames(Arrays.asList(l));

}

static Class mc() {

  return main.class;

}

static <A, B> void multiMapPut(Map<A, List<B>> map, A a, B b) {

  List<B> l = map.get(a);

  if (l == null)

    map.put(a, l = new ArrayList());

  l.add(b);

}

static String replacePrefix(String prefix, String replacement, String s) {

  if (!startsWith(s, prefix)) return s;

  return replacement + substring(s, l(prefix));

}

static String hideCredentials(URL url) { return url == null ? null : hideCredentials(str(url)); }

static String hideCredentials(String url) {

  return url.replaceAll("([&?])_pass=[^&\\s\"]*", "$1_pass=<hidden>");

}

static Throwable getInnerException(Throwable e) {

  while (e.getCause() != null)

    e = e.getCause();

  return e;

}

static int isAndroid_flag;

static boolean isAndroid() {

  if (isAndroid_flag == 0)

    isAndroid_flag = System.getProperty("java.vendor").toLowerCase().indexOf("android") >= 0 ? 1 : -1;

  return isAndroid_flag > 0;

}

static String substring(String s, int x) {

  return substring(s, x, l(s));

}

static String substring(String 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.substring(x, y);

}

static List<String> getClassNames(Collection l) {

  List<String> out = new ArrayList();

  if (l != null) for (Object o : l)

    out.add(o == null ? null : getClassName(o));

  return out;

}

static boolean startsWith(String a, String b) {

  return a != null && a.startsWith(b);

}

static boolean startsWith(String a, char c) {

  return nempty(a) && a.charAt(0) == c;

}

static boolean startsWith(List a, List b) {

  if (a == null || l(b) > l(a)) return false;

  for (int i = 0; i < l(b); i++)

    if (neq(a.get(i), b.get(i)))

      return false;

  return true;

}

static boolean nempty(Collection c) {

  return !isEmpty(c);

}

static boolean nempty(CharSequence s) {

  return !isEmpty(s);

}

static boolean nempty(Object[] o) {

  return !isEmpty(o);

}

static boolean nempty(Map m) {

  return !isEmpty(m);

}

static boolean nempty(Iterator i) {

  return i != null && i.hasNext();

}

static boolean isEmpty(Collection c) {

  return c == null || c.isEmpty();

}

static boolean isEmpty(CharSequence s) {

  return s == null || s.length() == 0;

}

static boolean isEmpty(Object[] a) {

  return a == null || a.length == 0;

}

static boolean isEmpty(Map map) {

  return map == null || map.isEmpty();

}

static abstract class F1<A, B> {

  abstract B get(A a);

}static class Pair<A, B> {

  A a;

  B b;

  Pair() {}

  Pair(A a, B b) {

  this.b = b;

  this.a = a;}

  public int hashCode() {

    return hashCodeFor(a) + 2*hashCodeFor(b);

  }

  public boolean equals(Object o) {

    if (o == this) return true;

    if (!(o instanceof Pair)) return false;

    Pair t = (Pair) o;

    return eq(a, t.a) && eq(b, t.b);

  }

  public String toString() {

    return "<" + a + ", " + b + ">";

  }

}

static int hashCodeFor(Object a) {

  return a == null ? 0 : a.hashCode();

}

}