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 {

  public static void main(String[] args) throws Exception {

    addToMultiPortSilent("Get Selected Table Line Helper Bot.");

  }

  static String answer(String s) {

    if (match3("get selected table line", s)) {

      Component focus = getFocusOwner();

      if (!(focus instanceof JTable)) return "no table";

      JTable tbl = (JTable) ( focus);

      return structure(getSelectedLine(tbl));

    }

    if (match3("get selected table line as map", s)) {

      Component focus = getFocusOwner();

      if (!(focus instanceof JTable)) return "no table";

      JTable tbl = (JTable) ( focus);

      return structure(getSelectedLineAsMap(tbl));

    }

    return null;

  }

static Map<String, String> getSelectedLineAsMap(JTable tbl) {

  int row = tbl.getSelectedRow();

  if (row >= 0 && row < tbl.getModel().getRowCount()) {

    Map<String, String> map = new TreeMap<String, String>();

    for (int i = 0; i < tbl.getModel().getColumnCount(); i++)

      map.put(tbl.getModel().getColumnName(i),

        String.valueOf(tbl.getModel().getValueAt(row, i)));

    return map;

  }

  return null;

}

static List<String> getSelectedLine(JTable tbl) {

  int row = tbl.getSelectedRow();

  if (row >= 0 && row < tbl.getModel().getRowCount()) {

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

    for (int i = 0; i < tbl.getModel().getColumnCount(); i++)

      l.add(String.valueOf(tbl.getModel().getValueAt(row, i)));

    return l;

  }

  return null;

}

static Component getFocusOwner() {

  return KeyboardFocusManager.getCurrentKeyboardFocusManager().getFocusOwner();

}

static long addToMultiPortSilent(String botName) {

  return addToMultiPort(botName);

}

  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

  }

 // class Matches

  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;

    List<String> tokpat = parse3(pat), toks = parse3(s);

    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;

    }

  }

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 "{" + 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()) + ")";

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

}

static Object addToMultiPort_responder;

static long addToMultiPort(final String botName) {

  return addToMultiPort(botName, new Object() {

    public String answer(String s, List<String> history) {

      String answer = (String) ( callOpt(getMainClass(), "answer", s, history));

      if (answer != null) return answer;

      answer = (String) callOpt(getMainClass(), "answer", s);

      if (answer != null) return answer;

      if (match3("get injection id", s))

        return getInjectionID();

      return null;

    }

  });

}

static long addToMultiPort(final String botName, final Object responder) {

  print(botName);

  addToMultiPort_responder = responder;

  startMultiPort();

  List ports = getMultiPorts();

  if (ports.isEmpty())

    fail("No multiports!");

  if (ports.size() > 1)

    print("Multiple multi-ports. Using last one.");

  Object port = last(ports);

  return (Long) call(port, "addResponder", botName, new Object() {

    public String answer(String s, List<String> history) {

      if (match3("get injection id", s))

        return getInjectionID();

      if (match3("your name", s))

        return botName;

      return (String) call(responder, "answer", s, history);

    }

  });

}

static Class include(String progID) {

  Class c = hotwire(progID);

  setOpt(c, "programID", getProgramID());

  return c;

}

static int l(Object[] array) {

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

}

static int l(List list) {

  return list == null ? 0 : list.size();

}

static int l(String s) {

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

} 

  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 List<String> parse3(String s) {

    return dropPunctuation(javaTokPlusPeriod(s));

  }

// 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 ("*".equals(p))

      result.add(t);

    else if (!p.equalsIgnoreCase(t))

      return null;

  }

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

}

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

  for (Field f : c.getDeclaredFields())

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

      return f;

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

}

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

  for (Field f : c.getDeclaredFields())

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

      return f;

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

}

static String shorten(String s, int max) {

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

}

static String getInjectionID() {

  return (String) call(getJavaX(), "getInjectionID", getMainClass());

}

// start multi-port if none exists in current VM.

static void startMultiPort() {

  // TODO: might start multiple if run concurrently...

  if (getMultiPorts().isEmpty())

    callMain(hotwire("#1001672"));

}

static List<Object> getMultiPorts() {

  return (List) call(getJavaX(), "getMultiPorts");

}

static int max(int a, int b) {

  return Math.max(a, b);

}

  static Object callOpt(Object o, String method, Object... args) {

    try {

      if (o == null) return null;

      if (o instanceof Class) {

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

        if (m == null) return null;

        m.setAccessible(true);

        return m.invoke(null, args);

      } else {

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

        if (m == null) return null;

        m.setAccessible(true);

        return m.invoke(o, args);

      }

    } catch (Exception e) {

      throw new RuntimeException(e);

    }

  }

  static Method callOpt_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 || !callOpt_checkArgs(m, args, debug))

          continue;

        return m;

      }

      c = c.getSuperclass();

    }

    return null;

  }

  static Method callOpt_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) && callOpt_checkArgs(m, args, debug))

          return m;

      }

      c = c.getSuperclass();

    }

    return null;

  }

  private static boolean callOpt_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 Class getMainClass() { try {

  return Class.forName("main");

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

static String programID;

static String getProgramID() {

  return programID;

}

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

  return l.isEmpty() ? null : l.get(l.size()-1);

}

  static void setOpt(Object o, String field, Object value) {

    if (o instanceof Class) setOpt((Class) o, field, value);

    else try {

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

      if (f == null) return;

      f.setAccessible(true);

      f.set(o, value);

    } catch (Exception e) {

      throw new RuntimeException(e);

    }

  }

  static void setOpt(Class c, String field, Object value) {

    try {

      Field f = setOpt_findStaticField(c, field);

      if (f == null) return;

      f.setAccessible(true);

      f.set(null, value);

    } catch (Exception e) {

      throw new RuntimeException(e);

    }

  }

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

    for (Field f : c.getDeclaredFields())

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

        return f;

    return null;

  }

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

    for (Field f : c.getDeclaredFields())

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

        return f;

    return null;

  }

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)) && !t.equals("*")) {

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

      tok.remove(i);

      tok.remove(i);

      i -= 2;

    }

  }

  return tok;

}

// This is made for NL parsing.

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

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 == '\'' || c == '"') {

      char opener = c;

      ++j;

      while (j < l) {

        if (s.charAt(j) == opener) {

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

}

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

  }

  // compile JavaX source, load classes & return main class

  // src can be a snippet ID or actual source code

  // TODO: record injection?

  static Class<?> hotwire(String src) {

    try {

      Class j = getJavaX();

      synchronized(j) { // hopefully this goes well...

        List<File> libraries = new ArrayList<File>();

        File srcDir = (File) call(j, "transpileMain", src, libraries);

        if (srcDir == null)

          fail("transpileMain returned null (src=" + quote(src) + ")");

        Object androidContext = get(j, "androidContext");

        if (androidContext != null)

          return (Class) call(j, "loadx2android", srcDir, src);

        File classesDir = (File) call(j, "TempDirMaker_make");

        String javacOutput = (String) call(j, "compileJava", srcDir, libraries, classesDir);

        System.out.println(javacOutput);

        URL[] urls = new URL[libraries.size()+1];

        urls[0] = classesDir.toURI().toURL();

        for (int i = 0; i < libraries.size(); i++)

          urls[i+1] = libraries.get(i).toURI().toURL();

        // make class loader

        URLClassLoader classLoader = new URLClassLoader(urls);

        // load & return main class

        Class<?> theClass = classLoader.loadClass("main");

        call(j, "setVars", theClass, isSnippetID(src) ? src: null);

        if (isSnippetID(src))

          callOpt(j, "addInstance", src, theClass);

        return theClass;

      }

    } catch (Exception e) {

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

    }

  }

  static RuntimeException fail() {

    throw new RuntimeException("fail");

  }

  static RuntimeException fail(Object msg) {

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

  }

static String programID() {

  return getProgramID();

}

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

  return type.isInstance(arg);

}

static Class __javax;

static Class getJavaX() {

  return __javax;

}

static void callMain(Object c, String... args) {

  callOpt(c, "main", new Object[] {args});

}

  public static boolean isSnippetID(String s) {

    try {

      parseSnippetID(s);

      return true;

    } catch (RuntimeException e) {

      return false;

    }

  }

public static long parseSnippetID(String snippetID) {

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

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

  return id;

}

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;

}

}