import java.math.*;

import javax.imageio.*;

import java.awt.image.*;

import java.awt.event.*;

import java.awt.*;

import java.security.spec.*;

import java.security.*;

import java.lang.management.*;

import java.lang.ref.*;

import java.lang.reflect.*;

import java.net.*;

import java.io.*;

import javax.swing.table.*;

import javax.swing.text.*;

import javax.swing.event.*;

import javax.swing.*;

import java.util.concurrent.atomic.*;

import java.util.concurrent.*;

import java.util.regex.*;

import java.util.List;

import java.util.zip.*;

import java.util.*;

public class main {

static String formatSnippetID(String id) {

  return "#" + parseSnippetID(id);

}

static String formatSnippetID(long id) {

  return "#" + id;

}

  public static String unquote(String s) {

    if (s.startsWith("[")) {

      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.startsWith("\"") && s.endsWith("\"") && s.length() > 1) {

      String st = s.substring(1, s.length()-1);

      StringBuilder sb = new StringBuilder(st.length());

      for (int i = 0; i < st.length(); i++) {

        char ch = st.charAt(i);

        if (ch == '\\') {

          char nextChar = (i == st.length() - 1) ? '\\' : st

                  .charAt(i + 1);

          // Octal escape?

          if (nextChar >= '0' && nextChar <= '7') {

              String code = "" + nextChar;

              i++;

              if ((i < st.length() - 1) && st.charAt(i + 1) >= '0'

                      && st.charAt(i + 1) <= '7') {

                  code += st.charAt(i + 1);

                  i++;

                  if ((i < st.length() - 1) && st.charAt(i + 1) >= '0'

                          && st.charAt(i + 1) <= '7') {

                      code += st.charAt(i + 1);

                      i++;

                  }

              }

              sb.append((char) Integer.parseInt(code, 8));

              continue;

          }

          switch (nextChar) {

          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 '\'':

              ch = '\'';

              break;

          // Hex Unicode: u????

          case 'u':

              if (i >= st.length() - 5) {

                  ch = 'u';

                  break;

              }

              int code = Integer.parseInt(

                      "" + st.charAt(i + 2) + st.charAt(i + 3)

                              + st.charAt(i + 4) + st.charAt(i + 5), 16);

              sb.append(Character.toChars(code));

              i += 5;

              continue;

          default:

            ch = nextChar; // added by Stefan

          }

          i++;

        }

        sb.append(ch);

      }

      return sb.toString();      

    } else

      return s; // return original

  }

  static class Matches {

    String[] m;

    String get(int i) { return m[i]; }

    String unq(int i) { return unquote(m[i]); }

    String fsi(int i) { return formatSnippetID(unq(i)); }

    boolean bool(int i) { return "true".equals(unq(i)); }

    String rest() { return m[m.length-1]; } // for matchStart

    int psi(int i) { return Integer.parseInt(unq(i)); }

  }

static String answer(String s) {

Matches m = new Matches();

  if (match("get transpilation of snippet *", s, m))

    return dropFirstLine(getServerTranspiled(m.fsi(0)));

  if (match("get libraries of snippet *", s, m))

    return quote(firstLine(getServerTranspiled(m.fsi(0))));

return null;

}

// returns libs in line 1, then transpiled souce

static String getServerTranspiled(String snippetID) { try {

  long id = parseSnippetID(snippetID);

  URL url = new URL("http://tinybrain.de:8080/tb-int/get-transpiled.php?raw=1&withlibs=1&id=" + id);

  return loadPage(url);

} catch (Throwable __e) { throw __e instanceof RuntimeException ? (RuntimeException) __e : new RuntimeException(__e); }}

  static String quote(String s) {

    if (s == null) return "null";

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

  }

  static String quote(long l) {

    return quote("" + l);

  }

static String dropFirstLine(String text) {

  int i = text.indexOf('\n');

  return i >= 0 ? text.substring(i+1) : "";

}

static String firstLine(String text) {

  int i = text.indexOf('\n');

  return i >= 0 ? text.substring(0, i) : text;

}

public static long parseSnippetID(String snippetID) {

  long id = Long.parseLong(shortenSnippetID(snippetID));

  if (id == 0) fail("0 is not a snippet ID");

  return id;

}

  public static String loadPageSilently(String url) {

    try {

      return loadPageSilently(new URL(loadPage_preprocess(url)));

    } catch (IOException e) { throw new RuntimeException(e); }

  }

  public static String loadPageSilently(URL url) {

    try {

      IOException e = null;

      for (int tries = 0; tries < 60; tries++)

        try {

          URLConnection con = url.openConnection();

          return loadPage(con, url);

        } catch (IOException _e) {

          e = _e;

          print("Retrying because of: " + e);

          sleepSeconds(1);

        }

      throw e;

    } catch (IOException e) { throw new RuntimeException(e); }

  }

  static String loadPage_preprocess(String url) {  

    if (url.startsWith("tb/"))

      url = "tinybrain.de:8080/" + url;

    if (url.indexOf("://") < 0)

      url = "http://" + url;

    return url;

  }

  public static String loadPage(String url) {

    try {

      return loadPage(new URL(loadPage_preprocess(url)));

    } catch (IOException e) { throw new RuntimeException(e); }

  }

  public static String loadPage(URL url) {

    print("Loading: " + url.toExternalForm());

    return loadPageSilently(url);

  }

  public static String loadPage(URLConnection con, URL url) throws IOException {

    String contentType = con.getContentType();

    if (contentType == null)

      throw new IOException("Page could not be read: " + url);

    //Log.info("Content-Type: " + contentType);

    String charset = loadPage_guessCharset(contentType);

    Reader r = new InputStreamReader(con.getInputStream(), charset);

    StringBuilder buf = new StringBuilder();

    while (true) {

      int ch = r.read();

      if (ch < 0)

        break;

      //Log.info("Chars read: " + buf.length());

      buf.append((char) ch);

    }

    return buf.toString();

  }

  static String loadPage_guessCharset(String contentType) {

    Pattern p = Pattern.compile("text/html;\\s+charset=([^\\s]+)\\s*");

    Matcher m = p.matcher(contentType);

    /* If Content-Type doesn't match this pre-conception, choose default and hope for the best. */

    return m.matches() ? m.group(1) : "ISO-8859-1";

  }

  static RuntimeException fail() {

    throw new RuntimeException("fail");

  }

  static RuntimeException fail(Object msg) {

    throw new RuntimeException(String.valueOf(msg));

  }

  static RuntimeException fail(String msg) {

    throw new RuntimeException(unnull(msg));

  }

  static RuntimeException fail(String msg, Object... args) {

    throw new RuntimeException(format(msg, args));

  }

static StringBuffer print_log;

static void print() {

  print("");

}

static void print(Object o) {

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

  synchronized(StringBuffer.class) {

    if (print_log == null) print_log = new StringBuffer();

  }

  print_log.append(s);

  System.out.print(s);

}

static void print(long l) {

  print(String.valueOf(l));

}

static void sleepSeconds(long s) {

  if (s > 0) sleep(s*1000);

}

static 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 snippetID;

}

  static String unnull(String s) {

    return s == null ? "" : s;

  }

  static List unnull(List l) {

    return l == null ? emptyList() : l;

  }

  static String format(String pat, Object... args) {

    return format3(pat, args);

  }

static void sleep(long ms) {

  try {

    Thread.sleep(ms);

  } catch (Exception e) { throw new RuntimeException(e); }

}

static void sleep() { try {

  print("Sleeping.");

  synchronized(main.class) { main.class.wait(); }

} catch (Throwable __e) { throw __e instanceof RuntimeException ? (RuntimeException) __e : new RuntimeException(__e); }}

  static String format3(String pat, Object... args) {

    if (args.length == 0) return pat;

    List<String> tok = javaTokPlusPeriod(pat);

    int argidx = 0;

    for (int i = 1; i < tok.size(); i += 2)

      if (tok.get(i).equals("*"))

        tok.set(i, format3_formatArg(argidx < args.length ? args[argidx++] : "null"));

    return join(tok);

  }

  static String format3_formatArg(Object arg) {

    if (arg == null) return "null";

    if (arg instanceof String) {

      String s = (String) arg;

      return isIdentifier(s) || isNonNegativeInteger(s) ? s : quote(s);

    }

    if (arg instanceof Integer || arg instanceof Long) return String.valueOf(arg);

    return quote(structure(arg));

  }

static List emptyList() {

  return Collections.emptyList();

}

static boolean isIdentifier(String s) {

  return isJavaIdentifier(s);

}

static boolean isNonNegativeInteger(String s) {

  return s != null && Pattern.matches("\\d+", s);

}

static String structure(Object o) {

  return structure(o, 0);

}

// leave to false, unless unstructure() breaks

static boolean structure_allowShortening = false;

static String structure(Object o, int stringSizeLimit) {

  if (o == null) return "null";

  String name = o.getClass().getName();

  StringBuilder buf = new StringBuilder();

  if (o instanceof Collection) { // TODO: store the type (e.g. HashSet/TreeSet)

    for (Object x : (Collection) o) {

      if (buf.length() != 0) buf.append(", ");

      buf.append(structure(x, stringSizeLimit));

    }

    return "[" + buf + "]";

  }

  if (o instanceof Map) {

    for (Object e : ((Map) o).entrySet()) {

      if (buf.length() != 0) buf.append(", ");

      buf.append(structure(((Map.Entry) e).getKey(), stringSizeLimit));

      buf.append("=");

      buf.append(structure(((Map.Entry) e).getValue(), stringSizeLimit));

    }

    return (o instanceof HashMap ? "hashmap" : "") + "{" + buf + "}";

  }

  if (o.getClass().isArray()) {

    int n = Array.getLength(o);

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

      if (buf.length() != 0) buf.append(", ");

      buf.append(structure(Array.get(o, i), stringSizeLimit));

    }

    return "array{" + buf + "}";

  }

  if (o instanceof String)

    return quote(stringSizeLimit != 0 ? shorten((String) o, stringSizeLimit) : (String) o);

  if (o instanceof Class)

    return "class(" + quote(((Class) o).getName()) + ")";

  if (o instanceof Throwable)

    return "exception(" + quote(((Throwable) o).getMessage()) + ")";

  if (o instanceof BigInteger)

    return "bigint(" + o + ")";

  if (o instanceof Double)

    return "d(" + quote(str(o)) + ")";

  if (o instanceof Long)

    return o + "L";

  // Need more cases? This should cover all library classes...

  if (name.startsWith("java.") || name.startsWith("javax."))

    return String.valueOf(o);

  String shortName = o.getClass().getName().replaceAll("^main\\$", "");

  int numFields = 0;

  String fieldName = "";

  if (shortName.equals("DynamicObject")) {

    shortName = (String) get(o, "className");

    Map<String, Object> fieldValues = (Map) get(o, "fieldValues");

    for (String _fieldName : fieldValues.keySet()) {

      fieldName = _fieldName;

      Object value = fieldValues.get(fieldName);

      if (value != null) {

        if (buf.length() != 0) buf.append(", ");

        buf.append(fieldName + "=" + structure(value, stringSizeLimit));

      }

      ++numFields;

   }

  } else {

    // regular class

    // TODO: go to superclasses too

    Field[] fields = o.getClass().getDeclaredFields();

    for (Field field : fields) {

      if ((field.getModifiers() & Modifier.STATIC) != 0)

        continue;

      Object value;

      try {

        field.setAccessible(true);

        value = field.get(o);

      } catch (Exception e) {

        value = "?";

      }

      fieldName = field.getName();

      // put special cases here...

      if (value != null) {

        if (buf.length() != 0) buf.append(", ");

        buf.append(fieldName + "=" + structure(value, stringSizeLimit));

      }

      ++numFields;

    }

  }

  String b = buf.toString();

  if (numFields == 1 && structure_allowShortening)

    b = b.replaceAll("^" + fieldName + "=", ""); // drop field name if only one

  String s = shortName;

  if (buf.length() != 0)

    s += "(" + b + ")";

  return s;

}

// This is made for NL parsing.

// It's javaTok extended with "..." token, "$n" and "#n" and

// special quotes (which are converted to normal ones).

static List<String> javaTokPlusPeriod(String s) {

  List<String> tok = new ArrayList<String>();

  int l = s.length();

  int i = 0;

  while (i < l) {

    int j = i;

    char c; String cc;

    // scan for whitespace

    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));

    // scan for non-whitespace

    if (c == '\u201C' || c == '\u201D') c = '"'; // normalize quotes

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

      char opener = c;

      ++j;

      while (j < l) {

        char _c = s.charAt(j);

        if (_c == '\u201C' || _c == '\u201D') _c = '"'; // normalize quotes

        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) == '\'')); // for things like "this one's"

    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 (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;

}

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

    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));

  }

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

    return join("", strings);

  }

  public static String join(String[] strings) {

    return join("", strings);

  }

static String shorten(String s, int max) {

  if (s == null) return "";

  return s.length() <= max ? s : s.substring(0, Math.min(s.length(), max)) + "...";

}

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

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

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

}

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

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

}

// get purpose 2: access a field by reflection

static Object get(Object o, String field) {

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

  if (o.getClass().getName().equals("main$DynamicObject"))

    return call(get_raw(o, "fieldValues"), "get", field);

  return get_raw(o, field);

}

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() & 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 String str(Object o) {

  return String.valueOf(o);

}

static boolean isJavaIdentifier(String s) {

  if (s.length() == 0 || !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 int l(Object[] array) {

  return array == null ? 0 : array.length;

}

static int l(byte[] array) {

  return array == null ? 0 : array.length;

}

static int l(int[] array) {

  return array == null ? 0 : array.length;

}

static int l(char[] array) {

  return array == null ? 0 : array.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(String s) {

  return s == null ? 0 : s.length();

} 

  // 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() & 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;

  }

// 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 boolean match(String pat, String s) {

  return match3(pat, s);

}

static boolean match(String pat, String s, Matches matches) {

  return match3(pat, s, matches);

}

static String unq(String s) {

  return unquote(s);

}

  // class Matches is added by #752

  static boolean match3(String pat, String s) {

    return match3(pat, s, null);

  }

  static boolean match3(String pat, String s, Matches matches) {

    if (s == null) return false;

    return match3(pat, parse3(s), matches);

  }

  static boolean match3(String pat, List<String> toks, Matches matches) {

    List<String> tokpat = parse3(pat);

    return match3(tokpat,toks,matches);

  }

  static boolean match3(List<String> tokpat, List<String> toks, Matches matches) {

    String[] m = match2(tokpat, toks);

    //print(structure(tokpat) + " on " + structure(toks) + " => " + structure(m));

    if (m == null)

      return false;

    else {

      if (matches != null) matches.m = m;

      return true;

    }

  }

// match2 matches multiple "*" (matches a single token) wildcards and zero or one "..." wildcards (matches multiple tokens)

static String[] match2(List<String> pat, List<String> tok) {

  // standard case (no ...)

  int i = pat.indexOf("...");

  if (i < 0) return match2_match(pat, tok);

  pat = new ArrayList<String>(pat); // We're modifying it, so copy first

  pat.set(i, "*");

  while (pat.size() < tok.size()) {

    pat.add(i, "*");

    pat.add(i+1, ""); // doesn't matter

  }

  return match2_match(pat, tok);

}

static String[] match2_match(List<String> pat, List<String> tok) {

  List<String> result = new ArrayList<String>();

  if (pat.size() != tok.size()) {

    /*if (debug)

      print("Size mismatch: " + structure(pat) + " vs " + structure(tok));*/

    return null;

  }

  for (int i = 1; i < pat.size(); i += 2) {

    String p = pat.get(i), t = tok.get(i);

    /*if (debug)

      print("Checking " + p + " against " + t);*/

    if (eq(p, "*"))

      result.add(t);

    else if (!equalsIgnoreCase(unquote(p), unquote(t))) // bold change - match quoted and unquoted now

      return null;

  }

  return result.toArray(new String[result.size()]);

}

  static List<String> parse3(String s) {

    return dropPunctuation(javaTokPlusPeriod(s));

  }

static boolean equalsIgnoreCase(String a, String b) {

  return a == null ? b == null : a.equalsIgnoreCase(b);

}

static List<String> dropPunctuation_keep = litlist("*", "<", ">");

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

  tok = new ArrayList<String>(tok);

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

    String t = tok.get(i);

    if (t.length() == 1 && !Character.isLetter(t.charAt(0)) && !Character.isDigit(t.charAt(0)) && !dropPunctuation_keep.contains(t)) {

      tok.set(i-1, tok.get(i-1) + tok.get(i+1));

      tok.remove(i);

      tok.remove(i);

      i -= 2;

    }

  }

  return tok;

}

static String dropPunctuation(String s) {

  return join(dropPunctuation(nlTok(s)));

}

static boolean eq(Object a, Object b) {

  if (a == null) return b == null;

  if (a.equals(b)) return true;

  if (a instanceof BigInteger) {

    if (b instanceof Integer) return a.equals(BigInteger.valueOf((Integer) b));

    if (b instanceof Long) return a.equals(BigInteger.valueOf((Long) b));

  }

  return false;

}

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

  return new ArrayList<A>(Arrays.asList(a));

}

static List<String> nlTok(String s) {

  return javaTokPlusPeriod(s);

}

}