import javax.imageio.*;
import java.security.NoSuchAlgorithmException;
import java.security.MessageDigest;
import java.lang.management.*;
import java.lang.reflect.*;
import java.net.*;
import java.io.*;
import java.util.concurrent.atomic.*;
import java.util.concurrent.*;
import java.util.regex.*;
import java.util.List;
import java.util.zip.*;
import java.util.*;

import android.widget.*;
import android.view.*;
import android.view.View;
import android.content.Context;
import android.app.Activity;
import android.view.inputmethod.*;
import android.content.*;
import android.text.*;

public class main {
  static String leoID = "#1001297";
  
  static List<Prog> programsStarted = new ArrayList<Prog>();

  static class Prog {
    String snippetID;
    Thread thread;
  }

  static class Lg {
    static int maxBufferLength = 2048;
    
    Activity context;
    ScrollView sv;
    TextView tv;
    StringBuilder buf = new StringBuilder();
    
    Lg(Activity context) {
      this.context = context;
      sv = new ScrollView(context);
      tv = new TextView(context);
      tv.setText(buf.toString());
      sv.addView(tv);
    }
    
    View getView() {
      return sv;
    }
    
    void shortenBuffer() {
      while (buf.length() > maxBufferLength) {
        String s = buf.toString();
        int i = s.indexOf('\n');
        if (i < 0) return;
        buf = new StringBuilder(s.substring(i+1));
      }
    }
    
    void print(final String s) {
      context.runOnUiThread(new Runnable() {
        public void run() {
          buf.append(s);
          shortenBuffer();
          tv.setText(buf.toString());
          
          sv.post(new Runnable() {
            public void run() {
              // This method works but animates the scrolling 
              // which looks weird on first load
              sv.fullScroll(View.FOCUS_DOWN);

              // This method works even better because there are no animations.
              //sv.scrollTo(0, sv.getBottom());
            }
          });
        }
      });
    }
    
    void println(String s) {
      print(s + "\n");
    }
  }
  
  public static View main(final Activity context) throws Exception {
    x27.androidContext = context;
    final File defSnip = new File(x27.userHome(), ".javax/defsnip");
    String id = x27.loadTextFile(defSnip.getPath(), "636");
 final File defargs = new File(x27.userHome(), ".javax/defargs");
    String arg = x27.loadTextFile(defargs.getPath(), "leo");

    ScrollView sv = new ScrollView(context);
    LinearLayout ll = new LinearLayout(context);
    ll.setOrientation(LinearLayout.VERTICAL);
    
    LinearLayout line1 = new LinearLayout(context);
    
    TextView label = new TextView(context);
    label.setText("Run which snippet ID?");
    line1.addView(label);
    
    final EditText tv = new EditText(context);
    // BAD - tv.setInputType(InputType.TYPE_NUMBER_FLAG_DECIMAL);
    tv.setInputType(InputType.TYPE_CLASS_TEXT | InputType.TYPE_CLASS_NUMBER);
    tv.setText(id);
    line1.addView(tv);
    
    Button btnGo = new Button(context);
    btnGo.setText("Go");
    line1.addView(btnGo);
    
    ll.addView(line1);
    
    LinearLayout line2 = new LinearLayout(context);
    
    label = new TextView(context);
    label.setText("Program arguments:");
    line2.addView(label);
    
    final EditText tvArgs = new EditText(context);
    tvArgs.setText(arg);
    line2.addView(tvArgs);
    
    ll.addView(line2);
    
    LinearLayout line3 = new LinearLayout(context);
    
    Button btnLeo = new Button(context);
    btnLeo.setText("Sprechen mit Leo");
    line3.addView(btnLeo);
    
    ll.addView(line3);
    
    btnGo.setOnClickListener(new View.OnClickListener() {
      public void onClick(View v) {
        hideKeyboard(context);
        String snippetID = tv.getText().toString();
        String text = "Running: " + snippetID;
        Toast.makeText(context, text, 2000).show();
        
        try {
          x27.saveTextFile(defSnip.getPath(), snippetID);
          x27.saveTextFile(defargs.getPath(), tvArgs.getText().toString());
        } catch (IOException e) {
        }
        run(context, snippetID, tvArgs.getText().toString().split(" +"));
      }
    });

    btnLeo.setOnClickListener(new View.OnClickListener() {
      public void onClick(View v) {
        run(context, leoID, new String[0]);
      }
    });

    sv.addView(ll);
    return sv;
  }
  
  static Lg lg;
  
  public static void run(final Activity context, final String mainSnippet, final String[] args) {
    lg = new Lg(context);
    
    OutputStream outputStream = new OutputStream() {
      public void write(int b) {
        try {
          lg.print(new String(new byte[] {(byte) b}, "UTF-8")); // This is crap
        } catch (UnsupportedEncodingException e) {}
      }
      
      @Override
      public void write(byte[] b, int off, int len) {
        try {
          lg.print(new String(b, off, len, "UTF-8")); // This is crap
        } catch (UnsupportedEncodingException e) {}
      }
    };
    
    PrintStream ps = new PrintStream(outputStream, true);
    System.setOut(ps);
    System.setErr(ps);
    
    Prog prog = new Prog();
    prog.snippetID = mainSnippet;

    prog.thread = new Thread() {
      public void run() {
        try {
          String[] a = new String[args.length+1];
          System.arraycopy(args, 0, a, 1, args.length);
          a[0] = mainSnippet;
          x27.main(a);
        } catch (Throwable e) {
          System.out.println("Whoa!");
          e.printStackTrace();
        }
      }
    };
    
    programsStarted.add(prog);
    prog.thread.start();
    
    context.setContentView(lg.getView());
  }
  
  static void setContentViewInUIThread(final View view) {
    ((Activity) x27.androidContext).runOnUiThread(new Runnable() {
      public void run() {
        ((Activity) x27.androidContext).setContentView(view);
      }
    });
  }
  
  public static void hideKeyboard(Activity context) {   
    View view = context.getCurrentFocus();
    if (view != null) {
        InputMethodManager inputManager = (InputMethodManager) context.getSystemService(Context.INPUT_METHOD_SERVICE);
        inputManager.hideSoftInputFromWindow(view.getWindowToken(), InputMethodManager.HIDE_NOT_ALWAYS);
    }
  }
  
  static void onActivityResult(int requestCode, int resultCode, Intent data) {
    if (x27.mainClass != null)
      x27.call(x27.mainClass, "onActivityResult", requestCode, resultCode, data);
  }
}

class x27 {
  static final String version = "JavaX 27";

  // If programs run longer than this, they might have their class files
  // deleted.
  static int tempFileRetentionTime = 24; // hours
  
  static boolean verbose = false, translate = false, list = false, virtualizeTranslators = true;
  static String translateTo = null;
  static boolean preferCached = false, noID = false, noPrefetch = false, noAWT = false;
  static boolean safeOnly = false, safeTranslate = false, javacOnly = false, logOn = true;
  static boolean runMainInProcess = true, consoleOn = true, hasHelloMessage = false;
  static List<String[]> mainTranslators = new ArrayList<String[]>();
  private static Map<Long, String> memSnippetCache = new HashMap<Long, String>();
  private static int processesStarted, compilations;

  // snippet ID -> md5
  private static HashMap<Long, String> prefetched = new HashMap<Long, String>();
  private static File virtCache;

  // doesn't work yet
  private static Map<String, Class<?>> programCache = new HashMap<String, Class<?>>();
  static boolean cacheTranslators = false;

  // this should work (caches transpiled translators)
  private static HashMap<Long, Object[]> translationCache = new HashMap<Long, Object[]>();
  static boolean cacheTranspiledTranslators = true;

  // which snippets are available pre-transpiled server-side?
  private static Set<Long> hasTranspiledSet = new HashSet<Long>();
  static boolean useServerTranspiled = true;

  static Object androidContext;
  static boolean android = isAndroid();
  
  // We stick to 1.7 for now to support android.
  // Scripts like #1001155 might change to 1.6
  static String javaTarget = System.getProperty("java.version").startsWith("1.6.") ? "1.6" : "1.7";

  // Translators currently being translated (to detect recursions)
  private static Set<Long> translating = new HashSet<Long>();

  static String lastOutput;
  static String[] fullArgs;

  static String javaCompilerOutput;

  public static void main(String[] args) {
    try {
      goMain(args);
    } catch (Throwable e) {
      e.printStackTrace();
    }
  }

static byte[] loadDataSnippetImpl(String snippetID) throws IOException {
  byte[] data;
  try {
    URL url = new URL("http://eyeocr.sourceforge.net/filestore/filestore.php?cmd=serve&file=blob_"
      + parseSnippetID(snippetID) + "&contentType=application/binary");
    System.err.println("Loading library: " + url);
    try {
      data = loadBinaryPage(url.openConnection());
    } catch (IOException e) {
      data = null;
    }
    
    if (data == null || data.length == 0) {
      url = new URL("http://data.tinybrain.de/blobs/"
        + parseSnippetID(snippetID));
      System.err.println("Loading library: " + url);
      data = loadBinaryPage(url.openConnection());
    }
    System.err.println("Bytes loaded: " + data.length);
  } catch (FileNotFoundException e) {
    throw new IOException("Binary snippet #" + snippetID + " not found or not public");
  }
  return data;
}
  
  static void goMain(String[] args) throws Exception {
    if (args.length != 0 && args[0].equals("-v")) verbose = true;

    for (String arg : args)
      if (arg.equals("-noawt"))
        noAWT = true;
        
    String autoReport = loadTextFile(new File(userHome(), ".javax/auto-report-to-chat").getPath(), "").trim();
    //print("autoReport=" + autoReport);
    if (!isChatServer(args) && autoReport.equals("1"))
      autoReportToChat();

    if (!hasHelloMessage) {
      hasHelloMessage = true;
      //installHelloMessage(args.length == 0 ? "JavaX Start-Up VM" : "JavaX VM (" + smartJoin(args) + ")");
      makeVMAndroid();
    }
    
    File ioBaseDir = new File("."), inputDir = null, outputDir = null;
    String src = null;
    List<String> programArgs = new ArrayList<String>();
    fullArgs = args;

    for (int i = 0; i < args.length; i++) {
      String arg = args[i];

      if (arg.equals("-version")) {
        showVersion();
        System.exit(0);
      }

      if (arg.equals("-sysprop")) {
        showSystemProperties();
        return;
      }

      if (arg.equals("-v") || arg.equals("-verbose"))
        verbose = true;
      else if (arg.equals("-finderror"))
        verbose = true;
      else if (arg.equals("-offline") || arg.equalsIgnoreCase("-prefercached"))
        preferCached = true;
      else if (arg.equals("-novirt"))
        virtualizeTranslators = false;
      else if (arg.equals("-safeonly"))
        safeOnly = true;
      else if (arg.equals("-safetranslate"))
        safeTranslate = true;
      else if (arg.equals("-noawt"))
        noAWT = true;
      else if (arg.equals("-noid"))
        noID = true;
      else if (arg.equals("-nocachetranspiled"))
        cacheTranspiledTranslators = false;
      else if (arg.equals("-javac"))
        javacOnly = true;
      else if (arg.equals("-localtranspile"))
        useServerTranspiled = false;
      else if (arg.equals("translate") && src == null)
        translate = true;
      else if (arg.equals("list") && src == null) {
        list = true;
        virtualizeTranslators = false; // so they are silenced
      } else if (arg.equals("run") && src == null) {
        // it's the default command anyway
      } else if (arg.startsWith("input="))
        inputDir = new File(arg.substring(6));
      else if (arg.startsWith("output="))
        outputDir = new File(arg.substring(7));
      else if (arg.equals("with"))
        mainTranslators.add(new String[] {args[++i], null});
      else if (translate && arg.equals("to"))
        translateTo = args[++i];
      else if (src == null) {
        //System.out.println("src=" + arg);
        src = arg;
      } else
        programArgs.add(arg);
    }

    cleanCache();

    if (useServerTranspiled)
      noPrefetch = true;

    if (src == null) src = ".";

    // Might actually want to write to 2 disk caches (global/per program).
    if (virtualizeTranslators && !preferCached)
      virtCache = TempDirMaker_make();

    if (inputDir != null) {
      ioBaseDir = TempDirMaker_make();
      System.out.println("Taking input from: " + inputDir.getAbsolutePath());
      System.out.println("Output is in: " + new File(ioBaseDir, "output").getAbsolutePath());
      copyInput(inputDir, new File(ioBaseDir, "input"));
    }
    
    if (logOn)
      logStart(args);

    javaxmain(src, ioBaseDir, translate, list, programArgs.toArray(new String[programArgs.size()]));

    if (outputDir != null) {
      copyInput(new File(ioBaseDir, "output"), outputDir);
      System.out.println("Output copied to: " + outputDir.getAbsolutePath());
    }

    if (verbose) {
      // print stats
      System.out.println("Processes started: " + processesStarted + ", compilations: " + compilations);
    }
  }

  public static void javaxmain(String src, File ioDir, boolean translate, boolean list,
                               String[] args) throws Exception {
    String programID = isSnippetID(src) ? "" + parseSnippetID(src) : null;
    
    if (programID != null)
      System.err.println("JavaX TRANSLATE " + programID + " " + smartJoin(args));
    
    List<File> libraries = new ArrayList<File>();
    File X = transpileMain(src, libraries);
    if (verbose)
      print("After transpileMain: " + X);
      
    if (X == null) {
      showVersion();
      
      if (fullArgs != null) {
        String[] nargs;
        if (fullArgs.length == 0)
          nargs = new String[] {"1000825"}; // swing-start
        else {
          // forward to search
          nargs = new String[fullArgs.length+1];
          nargs[0] = "636";
          // nargs[1] = "search-runnables";
          System.arraycopy(fullArgs, 0, nargs, 1, fullArgs.length);
        }
        main(nargs); // Hopefully we get no infinite recursion :)
        return;
      }
      
      System.out.println("No main.java found, exiting");
      return;
    }
    
    info.transpiledSrc = X;

    // list or run

    if (translate) {
      File to = X;
      if (translateTo != null) {
        StringBuilder buf = new StringBuilder();
        for (File f : libraries) buf.append(f.getName()+"\n");
        if (new File(translateTo).isDirectory()) {
          to = new File(translateTo, "main.java");
          saveTextFile(new File(translateTo, "libraries.txt").getPath(), buf.toString());
        } else {
          to = new File(translateTo);
          saveTextFile(new File(translateTo + "_libraries").getPath(), buf.toString());
        }
      }
      if (to != X)
        copy(new File(X, "main.java"), to);
      System.out.println("Program translated to: " + to.getAbsolutePath());
    } else if (list)
      System.out.println(loadTextFile(new File(X, "main.java").getPath(), null));
    else {
      if (programID != null)
        System.err.println("JavaX RUN " + programID + " " + smartJoin(args));
      System.err.println(); // Make empty line before actual program starts
      
      javax2(X, ioDir, false, runMainInProcess, libraries, args, null, programID, info);
      
      System.out.println("[main done]");
      
      // cleanup reportToChat thread
      if (reportToChat_q != null) {
        if (verbose) System.out.println("Closing reportToChat queue");
        reportToChat_q.done();
      }
    }
  }

  static File transpileMain(String src, List<File> libraries) throws Exception {
    File srcDir;
    boolean isTranspiled = false;
    if (isSnippetID(src)) {
      prefetch(src);
      long id = parseSnippetID(src);
      prefetched.remove(id); // hackfix to ensure transpiled main program is found.
      srcDir = loadSnippetAsMainJava(src);
      if (verbose)
        System.err.println("hasTranspiledSet: " + hasTranspiledSet);
      if (hasTranspiledSet.contains(id) && useServerTranspiled) {
        //System.err.println("Trying pretranspiled main program: #" + id);
        String transpiledSrc = getServerTranspiled("#" + id);
        int i = transpiledSrc.indexOf('\n');
        String libs = transpiledSrc.substring(0, Math.max(0, i));
        transpiledSrc = transpiledSrc.substring(i+1);
        if (!transpiledSrc.isEmpty()) {
          srcDir = TempDirMaker_make();
          saveTextFile(new File(srcDir, "main.java").getPath(), transpiledSrc);
          isTranspiled = true;
          //translationCache.put(id, new Object[] {srcDir, libraries});

          Matcher m = Pattern.compile("\\d+").matcher(libs);
          while (m.find()) {
            String libid = m.group();
            File libraryFile = DiskSnippetCache_getLibrary(parseSnippetID(libid));
            loadLibrary(libid, libraries, libraryFile);
          }
        }
      }
    } else {
      srcDir = new File(src);

      // if the argument is a file, it is assumed to be main.java
      if (srcDir.isFile()) {
        srcDir = TempDirMaker_make();
        copy(new File(src), new File(srcDir, "main.java"));
      }

      if (!new File(srcDir, "main.java").exists())
        return null;
    }

    // translate

    File X = srcDir;

    if (!isTranspiled) {
      X = topLevelTranslate(X, libraries);
      System.err.println("Translated " + src);

      // save prefetch data
      if (isSnippetID(src))
        savePrefetchData(src);
    }
    return X;
  }

  private static void prefetch(String mainSnippetID) throws IOException {
    if (noPrefetch) return;

    long mainID = parseSnippetID(mainSnippetID);
    String s = mainID + " " + loadTextFile(new File(userHome(), ".tinybrain/prefetch/" + mainID + ".txt").getPath(), "");
    String[] ids = s.trim().split(" ");
    if (ids.length > 1) {
      String url = "http://tinybrain.de:8080/tb-int/prefetch.php?ids=" + URLEncoder.encode(s, "UTF-8");
      String data = loadPage(new URL(url));
      String[] split = data.split(" ");
      if (split.length == ids.length)
        for (int i = 0; i < ids.length; i++)
          prefetched.put(parseSnippetID(ids[i]), split[i]);
    }
  }
  
  static String getDexCacheHome() {
    return ((File) call(androidContext, "getFilesDir")).getAbsolutePath();
  }

  static String _userHome;
  static String userHome() {
    if (_userHome == null) {
      if (isAndroid())
        _userHome = "/storage/sdcard0/";
      else
        _userHome = System.getProperty("user.home");
      //System.out.println("userHome: " + _userHome);
    }
    return _userHome;
  }

  private static void savePrefetchData(String mainSnippetID) throws IOException {
    List<String> ids = new ArrayList<String>();
    long mainID = parseSnippetID(mainSnippetID);

    for (long id : memSnippetCache.keySet())
      if (id != mainID)
        ids.add(String.valueOf(id));

    saveTextFile(new File(userHome(),".tinybrain/prefetch/" + mainID + ".txt").getPath(), join(" ", ids));
  }

  static File topLevelTranslate(File srcDir, List<File> libraries_out) throws Exception {
    File X = srcDir;
    X = applyTranslators(X, mainTranslators, libraries_out); // translators supplied on command line (unusual)

    // actual inner translation of the JavaX source
    X = defaultTranslate(X, libraries_out);
    return X;
  }

  private static File defaultTranslate(File x, List<File> libraries_out) throws Exception {
    x = luaPrintToJavaPrint(x);
    x = repeatAutoTranslate(x, libraries_out);
    return x;
  }

  private static File repeatAutoTranslate(File x, List<File> libraries_out) throws Exception {
    List<String[]> postTranslators = new ArrayList<String[]>();
    
    while (true) {
      String main = loadTextFile(new File(x, "main.java").getPath(), null);
      List<String> lines = toLines(main);
      List<String[]> t = findPostTranslators(lines);
      postTranslators.addAll(t);
      
      if (!t.isEmpty()) {
        main = fromLines(lines);
        x = TempDirMaker_make();
        saveTextFile(new File(x, "main.java").getPath(), main);
      }

      File y = autoTranslate(x, libraries_out);
      if (y == x)
        break;
      x = y;
    }
    
    x = applyTranslators(x, postTranslators, libraries_out);
    
    return x;
  }

  private static File autoTranslate(File x, List<File> libraries_out) throws Exception {
    String main = loadTextFile(new File(x, "main.java").getPath(), null);
    List<String> lines = toLines(main);
    List<String[]> translators = findTranslators(lines);
    if (translators.isEmpty())
      return x;

    main = fromLines(lines);
    File newDir = TempDirMaker_make();
    saveTextFile(new File(newDir, "main.java").getPath(), main);
    return applyTranslators(newDir, translators, libraries_out);
  }

  static List<String[]> findTranslators(List<String> lines) {
    List<String[]> translators = new ArrayList<String[]>();
    Pattern pattern = Pattern.compile("^!([0-9# \t]+)");
    Pattern pArgs = Pattern.compile("^\\s*\\((.*)\\)");
    for (ListIterator<String> iterator = lines.listIterator(); iterator.hasNext(); ) {
      String line = iterator.next();
      line = line.trim();
      Matcher matcher = pattern.matcher(line);
      if (matcher.find()) {
        String[] t = matcher.group(1).split("[ \t]+");
        String rest = line.substring(matcher.end());
        String arg = null;
        if (t.length == 1) {
          Matcher mArgs = pArgs.matcher(rest);
          if (mArgs.find())
            arg = mArgs.group(1);
        }
        for (String transi : t)
          translators.add(new String[]{transi, arg});
        iterator.remove();
      }
    }
    return translators;
  }

  static List<String[]> findPostTranslators(List<String> lines) {
    List<String[]> translators = new ArrayList<String[]>();
    Pattern pattern = Pattern.compile("^!post\\s*([0-9# \t]+)");
    Pattern pArgs = Pattern.compile("^\\s*\\((.*)\\)");
    for (ListIterator<String> iterator = lines.listIterator(); iterator.hasNext(); ) {
      String line = iterator.next();
      line = line.trim();
      Matcher matcher = pattern.matcher(line);
      if (matcher.find()) {
        String[] t = matcher.group(1).split("[ \t]+");
        String rest = line.substring(matcher.end());
        String arg = null;
        if (t.length == 1) {
          Matcher mArgs = pArgs.matcher(rest);
          if (mArgs.find())
            arg = mArgs.group(1);
        }
        for (String transi : t)
          translators.add(new String[]{transi, arg});
        iterator.remove();
      }
    }
    return translators;
  }

  public static List<String> toLines(String s) {
    List<String> lines = new ArrayList<String>();
    int start = 0;
    while (true) {
      int i = toLines_nextLineBreak(s, start);
      if (i < 0) {
        if (s.length() > start) lines.add(s.substring(start));
        break;
      }

      lines.add(s.substring(start, i));
      if (s.charAt(i) == '\r' && i+1 < s.length() && s.charAt(i+1) == '\n')
        i += 2;
      else
        ++i;

      start = i;
    }
    return lines;
  }

  private static int toLines_nextLineBreak(String s, int start) {
    for (int i = start; i < s.length(); i++) {
      char c = s.charAt(i);
      if (c == '\r' || c == '\n')
        return i;
    }
    return -1;
  }

  public static String fromLines(List<String> lines) {
    StringBuilder buf = new StringBuilder();
    for (String line : lines) {
      buf.append(line).append('\n');
    }
    return buf.toString();
  }

  private static File applyTranslators(File x, List<String[]> translators, List<File> libraries_out) throws Exception {
    for (String[] translator : translators)
      x = applyTranslator(x, translator[0], translator[1], libraries_out);
    return x;
  }

  // also takes a library
  private static File applyTranslator(File x, String translator, String arg, List<File> libraries_out) throws Exception {
    if (verbose)
      System.out.println("Using translator " + translator + " on sources in " + x.getPath());

    File newDir = runTranslatorOnInput(translator, null, arg, x, !verbose, libraries_out);

    if (!new File(newDir, "main.java").exists()) {
      throw new Exception("Translator " + translator + " did not generate main.java");
      // TODO: show translator output
    }
    if (verbose)
      System.out.println("Translated with " + translator + " from " + x.getPath() + " to " + newDir.getPath());
    x = newDir;
    return x;
  }

  private static File luaPrintToJavaPrint(File x) throws IOException {
    File newDir = TempDirMaker_make();
    String code = loadTextFile(new File(x, "main.java").getPath(), null);
    code = luaPrintToJavaPrint(code);
    saveTextFile(new File(newDir, "main.java").getPath(), code);
    return newDir;
  }

  public static String luaPrintToJavaPrint(String code) {
    return ("\n" + code).replaceAll(
      "(\n\\s*)print (\".*\")",
      "$1System.out.println($2);").substring(1);
  }

  public static File loadSnippetAsMainJava(String snippetID) throws IOException {
    checkProgramSafety(snippetID);
    File srcDir = TempDirMaker_make();
    saveTextFile(new File(srcDir, "main.java").getPath(), loadSnippet(snippetID));
    return srcDir;
  }

  public static File loadSnippetAsMainJavaVerified(String snippetID, String hash) throws IOException {
    checkProgramSafety(snippetID);
    File srcDir = TempDirMaker_make();
    saveTextFile(new File(srcDir, "main.java").getPath(), loadSnippetVerified(snippetID, hash));
    return srcDir;
  }

  @SuppressWarnings( "unchecked" )
  /** returns output dir */
  private static File runTranslatorOnInput(String snippetID, String hash, String arg, File input,
                                           boolean silent,
                                           List<File> libraries_out) throws Exception {
    if (safeTranslate)
      checkProgramSafetyImpl(snippetID);
    long id = parseSnippetID(snippetID);

    // It's a library, not a translator.
    File libraryFile = DiskSnippetCache_getLibrary(id);
    if (verbose)
      System.out.println("Library file for " + id + ": " + libraryFile);
    if (libraryFile != null) {
      loadLibrary(snippetID, libraries_out, libraryFile);
      return input;
    }

    String[] args = arg != null ? new String[]{arg} : new String[0];

    File srcDir = hash == null ? loadSnippetAsMainJava(snippetID)
      : loadSnippetAsMainJavaVerified(snippetID, hash);
    long mainJavaSize = new File(srcDir, "main.java").length();

    if (verbose)
      System.out.println(snippetID + ": length = " + mainJavaSize);
    if (mainJavaSize == 0) { // no text in snippet? assume it's a library
      loadLibrary(snippetID, libraries_out, libraryFile);
      return input;
    }

    List<File> libraries = new ArrayList<File>();
    Object[] cached = translationCache.get(id);
    if (cached != null) {
      //System.err.println("Taking translator " + snippetID + " from cache!");
      srcDir = (File) cached[0];
      libraries = (List<File>) cached[1];
    } else if (hasTranspiledSet.contains(id) && useServerTranspiled) {
      System.err.println("Trying pretranspiled translator: #" + snippetID);
      String transpiledSrc = getServerTranspiled(snippetID);
      transpiledSrc = transpiledSrc.substring(transpiledSrc.indexOf('\n')+1);
      // TODO: check for libraries
      if (!transpiledSrc.isEmpty()) {
        srcDir = TempDirMaker_make();
        saveTextFile(new File(srcDir, "main.java").getPath(), transpiledSrc);
        translationCache.put(id, cached = new Object[] {srcDir, libraries});
      }
    }

    File ioBaseDir = TempDirMaker_make();

    /*Class<?> mainClass = programCache.get("" + parseSnippetID(snippetID));
    if (mainClass != null)
      return runCached(ioBaseDir, input, args);*/
    // Doesn't work yet because virtualized directories are hardcoded in translator...

    if (cached == null) {
      System.err.println("Translating translator #" + id);
      if (translating.contains(id))
        throw new RuntimeException("Recursive translator reference chain including #" + id);
      translating.add(id);
      try {
        srcDir = defaultTranslate(srcDir, libraries);
      } finally {
        translating.remove(id);
      }
      System.err.println("Translated translator #" + id);
      translationCache.put(id, new Object[]{srcDir, libraries});
    }

    boolean runInProcess = false;

    if (virtualizeTranslators) {
      if (verbose) System.out.println("Virtualizing translator");

      // TODO: don't virtualize class _javax (as included in, say, #636)

      //srcDir = applyTranslator(srcDir, "#2000351"); // I/O-virtualize the translator
      // that doesn't work because it recurses infinitely...

      // So we do it right here:
      String s = loadTextFile(new File(srcDir, "main.java").getPath(), null);
      s = s.replaceAll("new\\s+File\\(", "virtual.newFile(");
      s = s.replaceAll("new\\s+FileInputStream\\(", "virtual.newFileInputStream(");
      s = s.replaceAll("new\\s+FileOutputStream\\(", "virtual.newFileOutputStream(");
      s += "\n\n" + loadSnippet("#2000355"); // load class virtual

      // forward snippet cache (virtualized one)
      File dir = virtCache != null ? virtCache : DiskSnippetCache_dir;
      s = s.replace("static File DiskSnippetCache_dir" + ";",
        "static File DiskSnippetCache_dir " + "= new File(" + javaQuote(dir.getAbsolutePath()) + ");"); // extra + is necessary for Dumb TinyBrain :)
      s = s.replace("static boolean preferCached = false;", "static boolean preferCached = true;");

      if (verbose) {
        System.out.println("==BEGIN VIRTUALIZED TRANSLATOR==");
        System.out.println(s);
        System.out.println("==END VIRTUALIZED TRANSLATOR==");
      }
      srcDir = TempDirMaker_make();
      saveTextFile(new File(srcDir, "main.java").getPath(), s);

      // TODO: silence translator also
      runInProcess = true;
    }

    return runJavaX(ioBaseDir, srcDir, input, silent, runInProcess, libraries,
      args, cacheTranslators ? "" + id : null, "" + id);
  }

  private static String getServerTranspiled(String snippetID) throws IOException {
    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);
  }

  static void checkProgramSafety(String snippetID) throws IOException {
    if (!safeOnly) return;
    checkProgramSafetyImpl(snippetID);
  }

  static void checkProgramSafetyImpl(String snippetID) throws IOException {
    URL url = new URL("http://tinybrain.de:8080/tb-int/is-javax-safe.php?id=" + parseSnippetID(snippetID));
    String text = loadPage(url);
    if (!text.startsWith("{\"safe\":\"1\"}"))
      throw new RuntimeException("Program not safe: #" + parseSnippetID(snippetID));
  }

  static void loadLibrary(String snippetID, List<File> libraries_out, File libraryFile) throws IOException {
    if (verbose)
      System.out.println("Assuming " + snippetID + " is a library.");

    if (libraryFile == null) {
      byte[] data = loadDataSnippetImpl(snippetID);
      DiskSnippetCache_putLibrary(parseSnippetID(snippetID), data);
      libraryFile = DiskSnippetCache_getLibrary(parseSnippetID(snippetID));
    }

    if (!libraries_out.contains(libraryFile))
      libraries_out.add(libraryFile);
  }

  private static byte[] loadDataSnippetImpl2(String snippetID) throws IOException {
    byte[] data;
    try {
      URL url = new URL("http://eyeocr.sourceforge.net/filestore/filestore.php?cmd=serve&file=blob_"
        + parseSnippetID(snippetID) + "&contentType=application/binary");
      System.err.println("Loading library: " + url);
      data = loadBinaryPage(url.openConnection());
      if (verbose)
        System.err.println("Bytes loaded: " + data.length);
    } catch (FileNotFoundException e) {
      throw new IOException("Binary snippet #" + snippetID + " not found or not public");
    }
    return data;
  }

  /** returns output dir */
  private static File runJavaX(File ioBaseDir, File originalSrcDir, File originalInput,
                               boolean silent, boolean runInProcess,
                               List<File> libraries, String[] args, String cacheAs,
                               String programID) throws Exception {
    File srcDir = new File(ioBaseDir, "src");
    File inputDir = new File(ioBaseDir, "input");
    File outputDir = new File(ioBaseDir, "output");
    copyInput(originalSrcDir, srcDir);
    copyInput(originalInput, inputDir);
    javax2(srcDir, ioBaseDir, silent, runInProcess, libraries, args, cacheAs, programID, null);
    return outputDir;
  }

  private static void copyInput(File src, File dst) throws IOException {
    copyDirectory(src, dst);
  }

  public static boolean hasFile(File inputDir, String name) {
    return new File(inputDir, name).exists();
  }

  public static void copyDirectory(File src, File dst) throws IOException {
    if (verbose) System.out.println("Copying " + src.getAbsolutePath() + " to " + dst.getAbsolutePath());
    dst.mkdirs();
    File[] files = src.listFiles();
    if (files == null) return;
    for (File file : files) {
      File dst1 = new File(dst, file.getName());
      if (file.isDirectory())
        copyDirectory(file, dst1);
      else {
        if (verbose) System.out.println("Copying " + file.getAbsolutePath() + " to " + dst1.getAbsolutePath());
        copy(file, dst1);
      }
    }
  }

  /** Quickly copy a file without a progress bar or any other fancy GUI... :) */
  public static void copy(File src, File dest) throws IOException {
    FileInputStream inputStream = newFileInputStream(src);
    FileOutputStream outputStream = newFileOutputStream(dest);
    try {
      copy(inputStream, outputStream);
      inputStream.close();
    } finally {
      outputStream.close();
    }
  }

  static Object call(Object o, String method, Object... args) {
    try {
      Method m = call_findMethod(o, method, args, false);
      m.setAccessible(true);
      return m.invoke(o, args);
    } catch (Exception e) {
      throw new RuntimeException(e);
    }
  }

  static Object call(Class c, String method, Object... args) {
    try {
      Method m = call_findStaticMethod(c, method, args, false);
      m.setAccessible(true);
      return m.invoke(null, args);
    } catch (Exception e) {
      throw new RuntimeException(e);
    }
  }

  static Method call_findStaticMethod(Class c, String method, Object[] args, boolean debug) {
    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("checkArgs: 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("checkArgs: Bad parameter " + i + ": " + args[i] + " vs " + types[i]);
        return false;
      }
    return true;
  }

  private static FileInputStream newFileInputStream(File f) throws FileNotFoundException {
    /*if (androidContext != null)
      return (FileInputStream) call(androidContext,
        "openFileInput", f.getPath());
    else*/
    return new // line break for Dumb TinyBrain :)
    FileInputStream(f);
  }

  private static FileOutputStream newFileOutputStream(File f) throws FileNotFoundException {
    /*if (androidContext != null)
      return (FileOutputStream) call(androidContext,
        "openFileOutput", f.getPath(), 0);
    else*/
    return new // line break for Dumb TinyBrain :)
    FileOutputStream(f);
  }

  public static void copy(InputStream in, OutputStream out) throws IOException {
    byte[] buf = new byte[65536];
    while (true) {
      int n = in.read(buf);
      if (n <= 0) return;
      out.write(buf, 0, n);
    }
  }

  /** writes safely (to temp file, then rename) */
  public static void saveTextFile(String fileName, String contents) throws IOException {
    File file = new File(fileName);
    File parentFile = file.getParentFile();
    if (parentFile != null)
      parentFile.mkdirs();
    String tempFileName = fileName + "_temp";
    FileOutputStream fileOutputStream = newFileOutputStream(new File(tempFileName));
    OutputStreamWriter outputStreamWriter = new OutputStreamWriter(fileOutputStream, charsetForTextFiles);
    PrintWriter printWriter = new PrintWriter(outputStreamWriter);
    printWriter.print(contents);
    printWriter.close();
    if (file.exists() && !file.delete())
      throw new IOException("Can't delete " + fileName);

    if (!new File(tempFileName).renameTo(file))
      throw new IOException("Can't rename " + tempFileName + " to " + fileName);
  }

  /** writes safely (to temp file, then rename) */
  public static void saveBinaryFile(String fileName, byte[] contents) throws IOException {
    File file = new File(fileName);
    File parentFile = file.getParentFile();
    if (parentFile != null)
      parentFile.mkdirs();
    String tempFileName = fileName + "_temp";
    FileOutputStream fileOutputStream = newFileOutputStream(new File(tempFileName));
    fileOutputStream.write(contents);
    fileOutputStream.close();
    if (file.exists() && !file.delete())
      throw new IOException("Can't delete " + fileName);

    if (!new File(tempFileName).renameTo(file))
      throw new IOException("Can't rename " + tempFileName + " to " + fileName);
  }

    public static String loadTextFile(String fileName) {
    try {
      return loadTextFile(fileName, null);
    } catch (IOException e) {
      throw new RuntimeException(e);
    }
  }
  
  public static String loadTextFile(String fileName, String defaultContents) throws IOException {
    if (!new File(fileName).exists())
      return defaultContents;

    FileInputStream fileInputStream = new FileInputStream(fileName);
    InputStreamReader inputStreamReader = new InputStreamReader(fileInputStream, "UTF-8");
    return loadTextFile(inputStreamReader);
  }
  
  public static String loadTextFile(File fileName) {
    try {
      return loadTextFile(fileName, null);
    } catch (IOException e) {
      throw new RuntimeException(e);
    }
  }

  public static String loadTextFile(File fileName, String defaultContents) throws IOException {
    try {
      return loadTextFile(fileName.getPath(), defaultContents);
    } catch (IOException e) {
      throw new RuntimeException(e);
    }
  }
  
  public static String loadTextFile(Reader reader) throws IOException {
    StringBuilder builder = new StringBuilder();
    try {
      char[] buffer = new char[1024];
      int n;
      while (-1 != (n = reader.read(buffer)))
        builder.append(buffer, 0, n);
        
    } finally {
      reader.close();
    }
    return builder.toString();
  } // loadTextFile
  
  static File DiskSnippetCache_dir;

  public static void initDiskSnippetCache(File dir) {
    DiskSnippetCache_dir = dir;
    dir.mkdirs();
  }

  // Data files are immutable, use centralized cache
  public static synchronized File DiskSnippetCache_getLibrary(long snippetID) throws IOException {
    File file = new File(getGlobalCache(), "data_" + snippetID + ".jar");
    if (verbose)
      System.out.println("Checking data cache: " + file.getPath());
    return file.exists() ? file : null;
  }

  public static synchronized String DiskSnippetCache_get(long snippetID) throws IOException {
    return loadTextFile(DiskSnippetCache_getFile(snippetID).getPath(), null);
  }

  private static File DiskSnippetCache_getFile(long snippetID) {
    return new File(DiskSnippetCache_dir, "" + snippetID);
  }

  public static synchronized void DiskSnippetCache_put(long snippetID, String snippet) throws IOException {
    saveTextFile(DiskSnippetCache_getFile(snippetID).getPath(), snippet);
  }

  public static synchronized void DiskSnippetCache_putLibrary(long snippetID, byte[] data) throws IOException {
    saveBinaryFile(new File(getGlobalCache(), "data_" + snippetID).getPath() + ".jar", data);
  }

  public static File DiskSnippetCache_getDir() {
    return DiskSnippetCache_dir;
  }

  public static void initSnippetCache() {
    if (DiskSnippetCache_dir == null)
      initDiskSnippetCache(getGlobalCache());
  }

  private static File getGlobalCache() {
    File file = new File(userHome(), ".tinybrain/snippet-cache");
    file.mkdirs();
    return file;
  }

  public static String loadSnippetVerified(String snippetID, String hash) throws IOException {
    String text = loadSnippet(snippetID);
    String realHash = getHash(text.getBytes("UTF-8"));
    if (!realHash.equals(hash)) {
      String msg;
      if (hash.isEmpty())
        msg = "Here's your hash for " + snippetID + ", please put in your program: " + realHash;
      else
        msg = "Hash mismatch for " + snippetID + ": " + realHash + " (new) vs " + hash + " - has tinybrain.de been hacked??";
      throw new RuntimeException(msg);
    }
    return text;
  }

  public static String getHash(byte[] data) {
    return bytesToHex(getFullFingerprint(data));
  }

  public static byte[] getFullFingerprint(byte[] data) {
    try {
      return MessageDigest.getInstance("MD5").digest(data);
    } catch (NoSuchAlgorithmException e) {
      throw new RuntimeException(e);
    }
  }

  public static String bytesToHex(byte[] bytes) {
    return bytesToHex(bytes, 0, bytes.length);
  }

  public static String bytesToHex(byte[] bytes, int ofs, int len) {
    StringBuilder stringBuilder = new StringBuilder(len*2);
    for (int i = 0; i < len; i++) {
      String s = "0" + Integer.toHexString(bytes[ofs+i]);
      stringBuilder.append(s.substring(s.length()-2, s.length()));
    }
    return stringBuilder.toString();
  }

  public static String loadSnippet(String snippetID) throws IOException {
    return loadSnippet(parseSnippetID(snippetID));
  }

  public static long parseSnippetID(String snippetID) {
    return Long.parseLong(shortenSnippetID(snippetID));
  }

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

  public static boolean isSnippetID(String snippetID) {
    snippetID = shortenSnippetID(snippetID);
    return isInteger(snippetID) && Long.parseLong(snippetID) != 0;
  }

  public static boolean isInteger(String s) {
    return Pattern.matches("\\-?\\d+", s);
  }

  public static String loadSnippet(long snippetID) throws IOException {
    String text = memSnippetCache.get(snippetID);
    if (text != null) {
      if (verbose)
        System.out.println("Getting " + snippetID + " from mem cache");
      return text;
    }

    initSnippetCache();
    text = DiskSnippetCache_get(snippetID);
    if (preferCached && text != null) {
      if (verbose)
        System.out.println("Getting " + snippetID + " from disk cache (preferCached)");
      return text;
    }

    String md5 = text != null ? md5(text) : "-";
    if (text != null) {
      String hash = prefetched.get(snippetID);
      if (hash != null) {
        if (md5.equals(hash)) {
          memSnippetCache.put(snippetID, text);
          if (verbose)
            System.out.println("Getting " + snippetID + " from prefetched");
          return text;
        } else
          prefetched.remove(snippetID); // (maybe this is not necessary)
      }
    }

    try {
      /*URL url = new URL("http://tinybrain.de:8080/getraw.php?id=" + snippetID);
      text = loadPage(url);*/
      String theURL = "http://tinybrain.de:8080/getraw.php?id=" + snippetID + "&getmd5=1&utf8=1&usetranspiled=1";
      if (text != null) {
        //System.err.println("MD5: " + md5);
        theURL += "&md5=" + md5;
      }
      URL url = new URL(theURL);
      String page = loadPage(url);

      // parse & drop transpilation flag available line
      int i = page.indexOf('\n');
      boolean hasTranspiled = page.substring(0, i).trim().equals("1");
      if (hasTranspiled)
        hasTranspiledSet.add(snippetID);
      else
        hasTranspiledSet.remove(snippetID);
      page = page.substring(i+1);

      if (page.startsWith("==*#*==")) {
        // same, keep text
        //System.err.println("Snippet unchanged, keeping.");
      } else {
        // drop md5 line
        i = page.indexOf('\n');
        String hash = page.substring(0, i).trim();
        text = page.substring(i+1);

        String myHash = md5(text);
        if (myHash.equals(hash)) {
          //System.err.println("Hash match: " + hash);
        } else
          System.err.println("Hash mismatch");
      }
    } catch (FileNotFoundException e) {
      e.printStackTrace();
      throw new IOException("Snippet #" + snippetID + " not found or not public");
    }

    memSnippetCache.put(snippetID, text);

    try {
      initSnippetCache();
      DiskSnippetCache_put(snippetID, text);
    } catch (IOException e) {
      System.err.println("Minor warning: Couldn't save snippet to cache ("  + DiskSnippetCache_getDir() + ")");
    }

    return text;
  }

  private static String md5(String text) {
    try {
      return bytesToHex(md5impl(text.getBytes("UTF-8"))); // maybe different than the way PHP does it...
    } catch (UnsupportedEncodingException e) {
      throw new RuntimeException(e);
    }
  }

  public static byte[] md5impl(byte[] data) {
    try {
      return MessageDigest.getInstance("MD5").digest(data);
    } catch (NoSuchAlgorithmException e) {
      throw new RuntimeException(e);
    }
  }

  private static String loadPage(URL url) throws IOException {
    System.err.println("Loading: " + url.toExternalForm());
    URLConnection con = url.openConnection();
    return loadPage(con, url);
  }

  public static String loadPage(URLConnection con, URL url) throws IOException {
    setHeaders(con);
    String contentType = con.getContentType();
    if (contentType == null)
      throw new IOException("Page could not be read: " + url);
    //Log.info("Content-Type: " + contentType);
    String charset = guessCharset(contentType);
    //System.err.println("Charset: " + charset);
    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();
  }

  public static byte[] loadBinaryPage(URLConnection con) throws IOException {
    setHeaders(con);
    return loadBinaryPage_noHeaders(con);
  }

  private static byte[] loadBinaryPage_noHeaders(URLConnection con) throws IOException {
    ByteArrayOutputStream buf = new ByteArrayOutputStream();
    InputStream inputStream = con.getInputStream();
    while (true) {
      int ch = inputStream.read();
      if (ch < 0)
        break;
      buf.write(ch);
    }
    inputStream.close();
    return buf.toByteArray();
  }

  private static void setHeaders(URLConnection con) throws IOException {
    String computerID = getComputerID();
    if (computerID != null)
      con.setRequestProperty("X-ComputerID", computerID);
  }

  public static String 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";
  }

  /** runs a transpiled set of sources */
  public static void javax2(File srcDir, File ioBaseDir, boolean silent, boolean runInProcess,
                            List<File> libraries, String[] args, String cacheAs,
                            String programID, Info info) throws Exception {
    if (android) {
      // TODO: no translator virtualization? huh?
      javax2android(srcDir, args, programID);
    } else {
      File classesDir = TempDirMaker_make();
      String javacOutput = compileJava(srcDir, libraries, classesDir);

      // run

      if (verbose) System.out.println("Running program (" + srcDir.getAbsolutePath()
        + ") on io dir " + ioBaseDir.getAbsolutePath() + (runInProcess ? "[in-process]" : "") + "\n");
      runProgram(javacOutput, classesDir, ioBaseDir, silent, runInProcess, libraries, args, cacheAs, programID, info);
    }
  }
  
  static Class<?> mainClass;

  static Class<?> loadx2android(File srcDir, String programID) throws Exception {
    /*
    URL url = new URL("http://tinybrain.de:8080/dexcompile.php");
    URLConnection conn = url.openConnection();
    String postData = "src=" + URLEncoder.encode(loadTextFile(new File(srcDir, "main.java").getPath(), null), "UTF-8");
    byte[] dexData = doPostBinary(postData, conn);*/
    
    byte[] dexData = loadBinaryPage(new URL("http://tinybrain.de:8080/dexcompile.php?id=" + parseSnippetID(programID)).openConnection());
    
    if (!isDex(dexData))
      throw new RuntimeException("Dex generation error: " + dexData.length + " bytes - " + new String(dexData, "UTF-8"));
    System.out.println("Dex loaded: " + dexData.length + "b");

    File dexDir = TempDirMaker_make();
    File dexFile = new File(dexDir, System.currentTimeMillis() + ".dex");
    File dexOutputDir = TempDirMaker_makeDexCache();

    System.out.println("Saving dex to: " + dexDir.getAbsolutePath());
    try {
      saveBinaryFile(dexFile.getPath(), dexData);
    } catch (Throwable e) {
      System.out.println("Whoa!");
      throw new RuntimeException(e);
    }

    System.out.println("Getting parent class loader.");
    ClassLoader parentClassLoader =
      //ClassLoader.getSystemClassLoader(); // does not find support jar
      //getClass().getClassLoader(); // Let's try this...
      x27.class.getClassLoader().getParent(); // XXX !

    //System.out.println("Making DexClassLoader.");
    //DexClassLoader classLoader = new DexClassLoader(dexFile.getAbsolutePath(), dexOutputDir.getAbsolutePath(), null,
    //  parentClassLoader);
    Class dcl = Class.forName("dalvik.system.DexClassLoader");
    Object classLoader = dcl.getConstructors()[0].newInstance(dexFile.getAbsolutePath(), dexOutputDir.getAbsolutePath(), null,
      parentClassLoader);

    //System.out.println("Loading main class.");
    //Class<?> theClass = classLoader.loadClass(mainClassName);
    Class<?> theClass = (Class<?>) call(classLoader, "loadClass", "main");
    mainClass = theClass;

    //System.out.println("Main class loaded.");
    try {
      set(theClass, "androidContext", androidContext);
    } catch (Throwable e) {}

    setVars(theClass, programID);

    return theClass;
  }

  static void javax2android(File srcDir, String[] args, String programID) throws Exception {
    Class<?> theClass = loadx2android(srcDir, programID);

    Method main = null;
    try {
      main = call_findStaticMethod(theClass, "main", new Object[]{androidContext}, false);
    } catch (RuntimeException e) {
    }

    //System.out.println("main method for " + androidContext + " of " + theClass + ": " + main);

    if (main != null) {
      // old style main program that returns a View
      System.out.println("Calling main (old-style)");
      Object view = main.invoke(null, androidContext);
      System.out.println("Calling setContentView with " + view);
      call(Class.forName("main"), "setContentViewInUIThread", view);
      //call(androidContext, "setContentView", view);
      System.out.println("Done.");
    } else {
      System.out.println("New-style main method running.\n\n====\n");
      runMainMethod(args, theClass);
    }
  }

  static byte[] DEX_FILE_MAGIC = { 0x64, 0x65, 0x78, 0x0a, 0x30, 0x33, 0x35, 0x00 };

  static boolean isDex(byte[] dexData) {
    if (dexData.length < DEX_FILE_MAGIC.length) return false;
    for (int i = 0; i < DEX_FILE_MAGIC.length; i++)
      if (dexData[i] != DEX_FILE_MAGIC[i])
        return false;
    return true;
  }

  static byte[] doPostBinary(String urlParameters, URLConnection conn) throws IOException {
    // connect and do POST
    setHeaders(conn);
    conn.setDoOutput(true);

    OutputStreamWriter writer = new OutputStreamWriter(conn.getOutputStream());
    writer.write(urlParameters);
    writer.flush();

    byte[] contents = loadBinaryPage_noHeaders(conn);
    writer.close();
    return contents;
  }

  static String compileJava(File srcDir, List<File> libraries, File classesDir) throws IOException {
    javaCompilerOutput = null;
    ++compilations;

    // collect sources

    List<File> sources = new ArrayList<File>();
    if (verbose) System.out.println("Scanning for sources in " + srcDir.getPath());
    scanForSources(srcDir, sources, true);
    if (sources.isEmpty())
      throw new IOException("No sources found");

    // compile

    File optionsFile = File.createTempFile("javax", "");
    if (verbose) System.out.println("Compiling " + sources.size() + " source(s) to " + classesDir.getPath());
    if (verbose) System.out.println("Libraries: " + libraries);
    String options = "-d " + bashQuote(classesDir.getPath());
    writeOptions(sources, libraries, optionsFile, options);
    classesDir.mkdirs();
    return javaCompilerOutput = invokeJavaCompiler(optionsFile);
  }

  private static void runProgram(String javacOutput, File classesDir, File ioBaseDir,
                                 boolean silent, boolean runInProcess,
                                 List<File> libraries, String[] args, String cacheAs,
                                 String programID, Info info) throws Exception {
    // print javac output if compile failed and it hasn't been printed yet
    if (info != null) {
      info.programID = programID;
      info.programArgs = args;
    }
    boolean didNotCompile = !didCompile(classesDir);
    if (verbose || didNotCompile)
      System.out.println(javacOutput);
    if (didNotCompile)
      return;

    if (runInProcess
      || (ioBaseDir.getAbsolutePath().equals(new File(".").getAbsolutePath()) && !silent)) {
      runProgramQuick(classesDir, libraries, args, cacheAs, programID, info, ioBaseDir);
      return;
    }

    boolean echoOK = false;
    // TODO: add libraries to class path
    String bashCmd = "(cd " + bashQuote(ioBaseDir.getAbsolutePath()) + " && (java -cp "
      + bashQuote(classesDir.getAbsolutePath()) + " main" + (echoOK ? "; echo ok" : "") + "))";
    if (verbose) System.out.println(bashCmd);
    String output = backtick(bashCmd);
    lastOutput = output;
    if (verbose || !silent)
      System.out.println(output);
  }

  static boolean didCompile(File classesDir) {
    return hasFile(classesDir, "main.class");
  }

  private static void runProgramQuick(File classesDir, List<File> libraries,
                                      String[] args, String cacheAs,
                                      String programID, Info info,
                                      File ioBaseDir) throws Exception {
    // collect urls
    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 JavaX main class
    Class<?> mainClass = classLoader.loadClass("main");
    
    if (info != null)
      info.mainClass = mainClass;
      
    if (cacheAs != null)
      programCache.put(cacheAs, mainClass);
      
    // change baseDir
    try {
      //print("Changing base dir to " + ioBaseDir.getAbsolutePath());
      Class virtual = mainClass.getClassLoader().loadClass("virtual");
      set(virtual, "virtual_baseDir", ioBaseDir.getAbsolutePath());
    } catch (Throwable e) { /* whatever */ }

    setVars(mainClass, programID);
    runMainMethod(args, mainClass);
  }

  static void setVars(Class<?> theClass, String programID) {
    try {
      set(theClass, "programID", programID);
    } catch (Throwable e) {}

    try {
      set(theClass, "__javax", x27.class);
    } catch (Throwable e) {}
  }


  static void runMainMethod(Object args, Class<?> mainClass) throws NoSuchMethodException, IllegalAccessException, InvocationTargetException {
    Method main = mainClass.getMethod("main", String[].class);
    main.invoke(null, args);
  }

  static String invokeJavaCompiler(File optionsFile) throws IOException {
    String output;
    if (hasEcj() && !javacOnly)
      output = invokeEcj(optionsFile);
    else
      output = invokeJavac(optionsFile);
    if (verbose) System.out.println(output);
    return output;
  }

  private static boolean hasEcj() {
    try {
      Class.forName("org.eclipse.jdt.internal.compiler.batch.Main");
      return true;
    } catch (ClassNotFoundException e) {
      return false;
    }
  }

  private static String invokeJavac(File optionsFile) throws IOException {
    String output;
    output = backtick("javac " + bashQuote("@" + optionsFile.getPath()));
    if (exitValue != 0) {
      System.out.println(output);
      throw new RuntimeException("javac returned errors.");
    }
    return output;
  }

  // throws ClassNotFoundException if ecj is not in classpath
  static String invokeEcj(File optionsFile) {
    try {
      StringWriter writer = new StringWriter();
      PrintWriter printWriter = new PrintWriter(writer);

      // add more eclipse options in the line below

      String[] args = {"@" + optionsFile.getPath(),
        "-source", javaTarget,
        "-target", javaTarget,
        "-nowarn"
      };

      Class ecjClass = Class.forName("org.eclipse.jdt.internal.compiler.batch.Main");
      Object main = newInstance(ecjClass, printWriter, printWriter, false);
      call(main, "compile", new Object[]{args});
      int errors = (Integer) get(main, "globalErrorsCount");

      String output = writer.toString();
      if (errors != 0) {
        System.out.println(output);
        throw new RuntimeException("Java compiler returned errors.");
      }
      return output;
    } catch (Exception e) {
      throw e instanceof RuntimeException ? (RuntimeException) e : new RuntimeException(e);
    }
  }

  static Object newInstance(Class c, Object... args) { try {
    Constructor m = findConstructor(c, args);
    m.setAccessible(true);
    return m.newInstance(args);
  } catch (Throwable __e) { throw __e instanceof RuntimeException ? (RuntimeException) __e : new RuntimeException(__e); }}

  static Constructor findConstructor(Class c, Object... args) {
    for (Constructor m : c.getDeclaredConstructors()) {
      if (!checkArgs(m.getParameterTypes(), args, verbose))
        continue;
      return m;
    }
    throw new RuntimeException("Constructor with " + args.length + " matching parameter(s) not found in " + c.getName());
  }

  static boolean checkArgs(Class[] types, Object[] args, boolean debug) {
    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 to handle primitive types
  private 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);
  }

  private static void writeOptions(List<File> sources, List<File> libraries,
                                   File optionsFile, String moreOptions) throws IOException {
    FileWriter writer = new FileWriter(optionsFile);
    for (File source : sources)
      writer.write(bashQuote(source.getPath()) + " ");
    if (!libraries.isEmpty()) {
      List<String> cp = new ArrayList<String>();
      for (File lib : libraries)
        cp.add(lib.getAbsolutePath());
      writer.write("-cp " + bashQuote(join(File.pathSeparator, cp)) + " ");
    }
    writer.write(moreOptions);
    writer.close();
  }

  static void scanForSources(File source, List<File> sources, boolean topLevel) {
    if (source.isFile() && source.getName().endsWith(".java"))
      sources.add(source);
    else if (source.isDirectory() && !isSkippedDirectoryName(source.getName(), topLevel)) {
      File[] files = source.listFiles();
      for (File file : files)
        scanForSources(file, sources, false);
    }
  }

  private static boolean isSkippedDirectoryName(String name, boolean topLevel) {
    if (topLevel) return false; // input or output ok as highest directory (intentionally specified by user, not just found by a directory scan in which case we probably don't want it. it's more like heuristics actually.)
    return name.equalsIgnoreCase("input") || name.equalsIgnoreCase("output");
  }

  static int exitValue;
  public static String backtick(String cmd) throws IOException {
    ++processesStarted;
    File outFile = File.createTempFile("_backtick", "");
    File scriptFile = File.createTempFile("_backtick", isWindows() ? ".bat" : "");

    String command = cmd + " >" + bashQuote(outFile.getPath()) + " 2>&1";
    //Log.info("[Backtick] " + command);
    try {
      saveTextFile(scriptFile.getPath(), command);
      String[] command2;
      if (isWindows())
        command2 = new String[] { scriptFile.getPath() };
      else
        command2 = new String[] { "/bin/bash", scriptFile.getPath() };
      Process process = Runtime.getRuntime().exec(command2);
      try {
        process.waitFor();
      } catch (InterruptedException e) {
        throw new RuntimeException(e);
      }
      exitValue = process.exitValue();
      if (verbose)
        System.out.println("Process return code: " + exitValue);
      return loadTextFile(outFile.getPath(), "");
    } finally {
      scriptFile.delete();
    }
  }

  /** possibly improvable */
  public static String javaQuote(String text) {
    return bashQuote(text);
  }

  /** possibly improvable */
  public static String bashQuote(String text) {
    if (text == null) return null;
    return "\"" + text
      .replace("\\", "\\\\")
      .replace("\"", "\\\"")
      .replace("\n", "\\n")
      .replace("\r", "\\r") + "\"";
  }

  public final static String charsetForTextFiles = "UTF8";

  static long TempDirMaker_lastValue;

  public static File TempDirMaker_makeDexCache() {
    File dir = new File(getDexCacheHome(), ".javax/" + TempDirMaker_newValue());
    dir.mkdirs();
    return dir;
  }

  public static File TempDirMaker_make() {
    File dir = new File(userHome(), ".javax/" + TempDirMaker_newValue());
    dir.mkdirs();
    return dir;
  }

  private static long TempDirMaker_newValue() {
    long value;
    do
      value = System.currentTimeMillis();
    while (value == TempDirMaker_lastValue);
    TempDirMaker_lastValue = value;
    return value;
  }

    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);
  }
 // join
  
  public static boolean isWindows() {
    return System.getProperty("os.name").contains("Windows");
  }

  public static String makeRandomID(int length) {
    Random random = new Random();
    char[] id = new char[length];
    for (int i = 0; i< id.length; i++)
      id[i] = (char) ((int) 'a' + random.nextInt(26));
    return new String(id);
  }

  static String computerID;
  public static String getComputerID() throws IOException {
    if (noID) return null;
    if (computerID == null) {
      File file = new File(userHome(), ".tinybrain/computer-id");
      computerID = loadTextFile(file.getPath(), null);
      if (computerID == null) {
        computerID = makeRandomID(12);
        saveTextFile(file.getPath(), computerID);
      }
      if (verbose)
        System.out.println("Local computer ID: " + computerID);
    }
    return computerID;
  }

  static int fileDeletions;

  static void cleanCache() {
    try {
      if (verbose)
        System.out.println("Cleaning cache");
      fileDeletions = 0;
      File javax = new File(userHome(), ".javax");
      long now = System.currentTimeMillis();
      File[] files = javax.listFiles();
      if (files != null) for (File dir : files) {
        if (dir.isDirectory() && Pattern.compile("\\d+").matcher(dir.getName()).matches()) {
          long time = Long.parseLong(dir.getName());
          long seconds = (now - time) / 1000;
          long minutes = seconds / 60;
          long hours = minutes / 60;
          if (hours >= tempFileRetentionTime) {
            //System.out.println("Can delete " + dir.getAbsolutePath() + ", age: " + hours + " h");
            removeDir(dir);
          }
        }
      }
      if (verbose && fileDeletions != 0)
        System.out.println("Cleaned cache. File deletions: " + fileDeletions);
    } catch (Throwable e) {
      e.printStackTrace();
    }
  }

  static void removeDir(File dir) {
    if (dir.getAbsolutePath().indexOf(".javax") < 0)  // security check!
      return;
    for (File f : dir.listFiles()) {
      if (f.isDirectory())
        removeDir(f);
      else {
        if (verbose)
          System.out.println("Deleting " + f.getAbsolutePath());
        f.delete();
        ++fileDeletions;
      }
    }
    dir.delete();
  }

  static void showSystemProperties() {
    System.out.println("System properties:\n");
    for (Map.Entry<Object, Object> entry : System.getProperties().entrySet()) {
      System.out.println("  " + entry.getKey() + " = " + entry.getValue());
    }
    System.out.println();
  }

  static void showVersion() {
    //showSystemProperties();
    boolean eclipseFound = hasEcj();
    //String platform = System.getProperty("java.vendor") + " " + System.getProperty("java.runtime.name") + " " + System.getProperty("java.version");
    String platform = System.getProperty("java.vm.name") + " " + System.getProperty("java.version");
    String os = System.getProperty("os.name"), arch = System.getProperty("os.arch");
    System.out.println("This is " + version + ".");
    System.out.println("[Details: " +
      (eclipseFound ? "Eclipse compiler (good)" : "javac (not so good)")
      + ", " + platform + ", " + arch + ", " + os + "]");
  }

  static boolean isAndroid() {
    return System.getProperty("java.vendor").toLowerCase().indexOf("android") >= 0;
  }
  
    static void set(Object o, String field, Object value) {
    if (o instanceof Class) set((Class) o, field, value);
    else try {
      Field f = set_findField(o.getClass(), field);
      f.setAccessible(true);
      f.set(o, value);
    } catch (Exception e) {
      throw new RuntimeException(e);
    }
  }
  
  static void set(Class c, String field, Object value) {
    try {
      Field f = set_findStaticField(c, field);
      f.setAccessible(true);
      f.set(null, value);
    } catch (Exception e) {
      throw new RuntimeException(e);
    }
  }
  
  static Field set_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 Field set_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());
  } // set function

  static String smartJoin(String[] args) {
    String[] a2 = new String[args.length];
    for (int i = 0; i < args.length; i++) {
      a2[i] = Pattern.compile("\\w+").matcher(args[i]).matches() ? args[i] : quote(args[i]);
    }
    return join(" ", a2);
  }
  
  static void logStart(String[] args) throws IOException {
    String line = smartJoin(args);
    appendToLog(new File(userHome(), ".javax/log.txt").getPath(), line);
  }
  
  static String quote(String s) {
    if (s == null) return "null";
    return "\"" + s.replace("\\", "\\\\").replace("\"", "\\\"").replace("\r", "\\r").replace("\n", "\\n") + "\"";
  }
  
  static void appendToLog(String path, String line) throws IOException {
    appendToFile(path, "\n" + line + "\n");
  }
  
  static void appendToFile(String path, String s) throws IOException {
    new File(path).getParentFile().mkdirs();
    Writer writer = new BufferedWriter(new OutputStreamWriter(
      new FileOutputStream(path, true), "UTF-8"));
    writer.write(s);
    writer.close();
  }

  static long now_virtualTime;
  static long now() {
    return now_virtualTime != 0 ? now_virtualTime : System.currentTimeMillis();
  }

  static void print(Object o) {
    System.out.println(o);
  }

  static void nohupJavax(String javaxargs) {
    try {
      File xfile = new File(userHome(), ".javax/x27.jar");
      if (!xfile.isFile()) {
        String url = "http://tinybrain.de/x27.jar";
        byte[] data = loadBinaryPage(new URL(url).openConnection());
        if (data.length < 1000000)
          throw new RuntimeException("Could not load " + url);
        saveBinaryFile(xfile.getPath(), data);
      }
      String jarPath = xfile.getPath();
      nohup("java -jar " + (isWindows() ? winQuote(jarPath) : bashQuote(jarPath)) + " " + javaxargs);
    } catch (Exception e) { throw new RuntimeException(e); }
  }

  /** possibly improvable */
  public static String winQuote(String text) {
    if (text == null) return null;
    return "\"" + text
      .replace("\\", "\\\\")
      .replace("\"", "\\\"")
      .replace("\n", "\\n")
      .replace("\r", "\\r") + "\"";
  }

  public static File nohup(String cmd) throws IOException {
    File outFile = File.createTempFile("nohup_" + nohup_sanitize(cmd), ".out");
    nohup(cmd, outFile, false);
    return outFile;
  }

  static String nohup_sanitize(String s) {
    return s.replaceAll("[^a-zA-Z0-9\\-_]", "");
  }

  /** outFile takes stdout and stderr. */
  public static void nohup(String cmd, File outFile, boolean append) throws IOException {
    String command = nohup_makeNohupCommand(cmd, outFile, append);

    File scriptFile = File.createTempFile("_realnohup", isWindows() ? ".bat" : "");
    System.out.println("[Nohup] " + command);
    try {
      //System.out.println("[RealNohup] Script file: " + scriptFile.getPath());
      saveTextFile(scriptFile.getPath(), command);
      String[] command2;
      if (isWindows())
        command2 = new String[] {"cmd", "/c", "start", "/b", scriptFile.getPath() };
      else
        command2 = new String[] {"/bin/bash", scriptFile.getPath() };

      Process process = Runtime.getRuntime().exec(command2);
      try {
        process.waitFor();
      } catch (InterruptedException e) {
        throw new RuntimeException(e);
      }
      int value = process.exitValue();
      //System.out.println("exit value: " + value);
    } finally {
      if (!isWindows())
        scriptFile.delete();
    }
  }

  public static String nohup_makeNohupCommand(String cmd, File outFile, boolean append) {
    mkdirsForFile(outFile);

    String command;
    if (isWindows())
      command = cmd + (append ? " >>" : " >") + winQuote(outFile.getPath()) + " 2>&1";
    else
      command = "nohup " + cmd + (append ? " >>" : " >") + bashQuote(outFile.getPath()) + " 2>&1 &";
    return command;
  }

  public static void mkdirsForFile(File file) {
    File dir = file.getParentFile();
    if (dir != null) // is null if file is in current dir
      dir.mkdirs();
  }
 
  static void autoReportToChat() {
    // TODO: put back in
  }
  
  static class Q {
    LinkedBlockingQueue<Runnable> q = new LinkedBlockingQueue<Runnable>();
    
    static class Done extends RuntimeException {}
    
    Q() {}
    
    Q(String name, boolean startThread) {
      if (startThread)
        new Thread(name) {
          public void run() {
            Q.this.run();
          }
        }.start();
    }
    
    Iterable<Runnable> master() {
      return new Iterable<Runnable>() {
        public Iterator<Runnable> iterator() {
          return new Iterator<Runnable>() {
            Runnable x;
            
            public boolean hasNext() { try {
   
              //debug("hasNext");
              while (x == null)
                x = q.poll(1, TimeUnit.DAYS);
              //debug("hasNext true");
              return true;
            
  } catch (Throwable __e) { throw __e instanceof RuntimeException ? (RuntimeException) __e : new RuntimeException(__e); }}
            
            public Runnable next() {
              //debug("next");
              hasNext();
              Runnable _x = x;
              x = null;
              //debug("next " + structure(x));
              return _x;
            }
            
            public void remove() {
            }
          };
        }
      };
    }
    
    void add(Runnable r) {
      q.add(r);
    }
    
    void run() {
      for (Runnable r : master()) {
        try {
          r.run();
        } catch (Done e) {
          return; // break signal
        } catch (Throwable e) {
          e.printStackTrace();
        }
      }
    }
    
    void done() {
      add(new Runnable() {
        public void run() {
          throw new Done();
        }
      });
    }
  } // class Q

static void reportToChat(final String s, boolean silent) {
    if (s == null || s.length() == 0) return;
    if (!silent)
      print("reportToChat: " + quote(s));
    reportToChat_getChatThread().add(new Runnable() {
    public void run() { try {
        startChatServerIfNotUp();
        waitForChatServer();
        chatSend(s);
    } catch (Exception __e) { throw __e instanceof RuntimeException ? (RuntimeException) __e : new RuntimeException(__e); }}});
   }
  
  static Q reportToChat_q;
  
  static Q reportToChat_getChatThread() {
    if (reportToChat_q == null)
      reportToChat_q = new Q("reportToChat", true);
    return reportToChat_q;
  }
  
  static void startChatServerIfNotUp() {
    if (portIsBound(9751)) {
      //print("Chat seems to be up.");
    } else {
      nohupJavax("1000867");
      print("Chat server should be coming up any minute now.");
    }
  }
  
  static void waitForChatServer() {
    if (!portIsBound(9751)) {
      //System.out.print("Waiting for chat server... ");
      do {
        sleep(1000);
      } while (!portIsBound(9751));
      //print("OK.");
    }
  }

  static boolean portIsBound(int port) {
    try {
      ServerSocket s = new ServerSocket(port);
      s.close();
      return false;
    } catch (IOException e) {
      return true;
    }
  }
  
  static class LineBuf {
    StringBuffer buf = new StringBuffer();
    
    void append(String s) {
      buf.append(s);
    }
    
    String nextLine() {
      int i = buf.indexOf("\n");
      if (i >= 0) {
        String s = buf.substring(0, i > 0 && buf.charAt(i-1) == '\r' ? i-1 : i);
        buf.delete(0, i+1);
        return s;
      }
      return null;
    }
  } // LineBuf

  static void sleep(long ms) {
    try {
      Thread.sleep(ms);
    } catch (Exception e) { throw new RuntimeException(e); }
  }


static int chatSend_chatPort = 9751;

  static abstract class DialogIO {
    abstract boolean isStillConnected();
    abstract String readLineNoBlock();
    abstract boolean waitForLine();
    abstract void sendLine(String line);
    abstract boolean isLocalConnection();
    abstract Socket getSocket();
  }
  
  static abstract class DialogHandler {
    abstract void run(DialogIO io);
  } // DialogIO

static DialogIO chatSend_dialog;
static String chatSend_id;

static void chatSend(String line) { try {
 
  if (chatSend_dialog == null) {
    chatSend_dialog = talkTo("localhost", chatSend_chatPort);    
    chatSend_dialog.waitForLine();
    String l = chatSend_dialog.readLineNoBlock();
    if (l.startsWith("Your ID: "))
      chatSend_id = l.substring("Your ID: ".length());
  }

  chatSend_dialog.sendLine(line);

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

  static class TeeOutputStream extends OutputStream {
    
    protected OutputStream out, branch;

    public TeeOutputStream( OutputStream out, OutputStream branch ) {
      this.out = out;
      this.branch = branch;
    }

    @Override
    public synchronized void write(byte[] b) throws IOException {
      write(b, 0, b.length);
    }

    @Override
    public synchronized void write(byte[] b, int off, int len) throws IOException {
      //if (verbose) oldOut.println("Tee write " + new String(b, "UTF-8"));
      out.write(b, off, len);
      this.branch.write(b, off, len);
    }

    @Override
    public synchronized void write(int b) throws IOException {
      write(new byte[] {(byte) b});
    }

    /**
     * Flushes both streams.
     * @throws IOException if an I/O error occurs
     */
    @Override
    public void flush() throws IOException {
      out.flush();
      this.branch.flush();
    }

    /**
     * Closes both streams.
     * @throws IOException if an I/O error occurs
     */
    @Override
    public void close() throws IOException {
      out.close();
      this.branch.close();
    }
  }
  
  static boolean isChatServer(String[] args) {
    for (int i = 0; i < args.length; i++)
      if (isSnippetID(args[i]))
        return parseSnippetID(args[i]) == 1000867;
    return false;
  }
  
  static String getSnippetTitle(String id) {
    try {
      return loadPage(new URL("http://tinybrain.de:8080/tb-int/getfield.php?id=" + parseSnippetID(id) + "&field=title"));
    } catch (Throwable __e) { throw __e instanceof RuntimeException ? (RuntimeException) __e : new RuntimeException(__e); }
  }
  
  static void listUserThreadsWithStackTraces() {
    print("");
    Map<Thread, StackTraceElement[]> threadMap = Thread.getAllStackTraces();
    int n = 0;
    for (Thread t : threadMap.keySet()) {
      ThreadGroup g = t.getThreadGroup();
      if (g != null && g.getName().equals("system")) continue;
      ++n;
      print(t);
      for (StackTraceElement e : threadMap.get(t)) {
        print("  " + e);
      }
      print("");
    }
    print(n + " user threads.");
  }
  
  static void killMyself() {
    print("Killing myself. (insert overall feeling here)");
    System.exit(0);
  }
  
  static void makeVMAndroid() {
    makeAndroidNoConsoleDaemon("This is a JavaX VM.", new StrF() {
public String get(String s) {
try { return  answer(s) ; } catch (Exception _e) {
  throw _e instanceof RuntimeException ? (RuntimeException) _e : new RuntimeException(_e); } }
});
  }
  
  static class Info {
    String programID;
    String[] programArgs;
    File transpiledSrc;
    Class mainClass;
  }
  
  static Info info = new Info();
  
  static synchronized String answer(String s) {
    Matches m = new Matches();
    
    if (match3("kill!", s)) {
      killMyself();
      return "ok";
    }
    if (match3("What is your process ID?", s) || match3("what is your pid?", s))
      return getPID();
    if (match3("what is your program id?", s))
      return info.programID;
    if (match3("what are your program arguments?", s))
      return structure(info.programArgs);
    if (match3("get fields of main class", s))
      return structure(listFields(info.mainClass));
    if (match3("get field * of main class", s, m))
      return structure(get(info.mainClass, m.m[0]));
    if (match3("invoke function * of main class", s, m))
      return structure(call(info.mainClass, m.m[0]));
    if (match3("set field * of main class to *", s, m)) {
      set(info.mainClass, m.m[0], unstructure(m.m[1]));
      return "ok";
    }
    if (match3("how much memory are you consuming", s))
      return "Java heap size: " + (Runtime.getRuntime().totalMemory()+1024*1024-1)/1024/1024 + " MB";
    if (match3("how much memory is used after GC?", s)) {
      System.gc();
      return "Java heap used: " + (Runtime.getRuntime().totalMemory()-Runtime.getRuntime().freeMemory()+1024*1024-1)/1024/1024 + " MB";
    }
    if (match3("how much memory is used?", s))
      return "Java heap used: " + (Runtime.getRuntime().totalMemory()-Runtime.getRuntime().freeMemory()+1024*1024-1)/1024/1024 + " MB";
    return null;
  }
  
static class Android {
  int port;
  DialogHandler handler;
}

static int makeAndroid(final String greeting) {
  return makeAndroid(greeting, new StrF() {
public String get(String s) {
try { return 
    (String) call(getMainClass(), "answer", s)
  ; } catch (Exception _e) {
  throw _e instanceof RuntimeException ? (RuntimeException) _e : new RuntimeException(_e); } }
});
}

static int makeAndroidNoConsole(final String greeting, final StrF f) {
  return makeAndroid(greeting, f, false, false);
}

static int makeAndroidNoConsoleDaemon(final String greeting, final StrF f) {
  return makeAndroid(greeting, f, false, true);
}

static int makeAndroid(final String greeting, final StrF f) {
  return makeAndroid(greeting, f, true, false);
}

static int makeAndroid(final String greeting, final StrF f, boolean console, boolean daemon) {
  print(greeting);
  final Android a = new Android();
  a.handler = makeAndroid_makeDialogHandler(greeting, f);
  a.port = daemon 
    ? startDialogServerOnPortAboveDaemon(5000, a.handler)
    : startDialogServerOnPortAbove(5000, a.handler);
  
  if (console) {
    print("You may also type on this console.");
    Thread _t_0 = new Thread() {
public void run() {
try {

      String line;
      while ((line = readLine()) != null) {
        if ("bye".equals(line))
          print("> bye stranger");
        else
          makeAndroid_getAnswer(line, f); // prints answer on console too
      }
    } catch (Exception _e) {
  throw _e instanceof RuntimeException ? (RuntimeException) _e : new RuntimeException(_e); } }
};
_t_0.start();
  }
  
  record(a);
  return a.port;
}

static DialogHandler makeAndroid_makeDialogHandler(final String greeting, final StrF f) {
  return new DialogHandler() {
public void run(final DialogIO io) {

    if (!(publicCommOn() || io.isLocalConnection())) {
      io.sendLine("Sorry, not allowed");
      return;
    }
    
    String dialogID = randomID(8);
    
    io.sendLine(greeting + " / Your ID: " + dialogID);
    
    while (io.isStillConnected()) {
      if (io.waitForLine()) {
        final String line = io.readLineNoBlock();
        String s = dialogID + " at " + now() + ": " + quote(line);
        print(s);
        if ("bye".equals(line)) {
          io.sendLine("bye stranger");
          return;
        }
        String answer = makeAndroid_getAnswer(line, f);
        io.sendLine(answer == null ? "null" : answer);
        //appendToLog(logFile, s);
      }
    }
  
}};
}

static String makeAndroid_getAnswer(String line, StrF f) {
  String answer;
  try {
    answer = makeAndroid_fallback(line, f.get(line));
  } catch (Throwable e) {
    e = getInnerException(e);
    e.printStackTrace();
    answer = e.toString();
  }
  print("> " + answer);
  return answer;
}

static String makeAndroid_fallback(String s, String answer) {
  if (answer == null) return "?";
  if (answer.indexOf('\n') >= 0 || answer.indexOf('\r') >= 0)
    answer = quote(answer);
  return answer;
}
 // makeAndroid / makeAndroidNoConsole
  static BufferedReader readLine_reader;

static String readLine() { try {
 
  if (readLine_reader == null)
    readLine_reader = new BufferedReader(new InputStreamReader(System.in, "UTF-8"));
  String s = readLine_reader.readLine();
  if (s != null)
    print(s);
  return s;

} catch (Throwable __e) { throw __e instanceof RuntimeException ? (RuntimeException) __e : new RuntimeException(__e); }} // readLine
    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_findStaticField(Class<?> c, String field) {
    for (Field f : c.getDeclaredFields())
      if (f.getName().equals(field) && (f.getModifiers() & Modifier.STATIC) != 0)
        return f;
    return null;
  } // setOpt
  static Object get(Object o, String field) {
  if (o instanceof Class) return get((Class) o, 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());
} // get
  static Class getMainClass() { try {
 
  return Class.forName("main");

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

static Throwable getInnerException(Throwable e) {
  while (e.getCause() != null)
    e = e.getCause();
  return e;
}

static boolean publicCommOn() {
  return "1".equals(loadTextFile(new File(userHome(), ".javax/public-communication")));
}

static List<Object> record_list = synchroList();

static void record(Object o) {
  record_list.add(o);
}

static Set<String> listFields(Class<?> c) {
  Set<String> fields = new TreeSet<String>();
  for (Field f : c.getDeclaredFields())
    fields.add(f.getName());
  return fields;
}

// try to get our current process ID
static String getPID() {
  String name = ManagementFactory.getRuntimeMXBean().getName();
  return name.replaceAll("@.*", "");
}

  static AtomicInteger dialogServer_clients = new AtomicInteger();
  
  static int startDialogServerOnPortAbove(int port, DialogHandler handler) {
    while (!startDialogServerIfPortAvailable(port, handler))
      ++port;
    return port;
  }
  
  static int startDialogServerOnPortAboveDaemon(int port, DialogHandler handler) {
    while (!startDialogServerIfPortAvailable(port, handler, true))
      ++port;
    return port;
  }
  
  static void startDialogServer(int port, DialogHandler handler) {
    if (!startDialogServerIfPortAvailable(port, handler))
      fail("Can't start dialog server on port " + port);
  }
  
  static boolean startDialogServerIfPortAvailable(int port, final DialogHandler handler) {
    return startDialogServerIfPortAvailable(port, handler, false);
  }
    
  static boolean startDialogServerIfPortAvailable(int port, final DialogHandler handler, boolean daemon) {
    ServerSocket serverSocket = null;
    try {
      serverSocket = new ServerSocket(port);
    } catch (IOException e) {
      // probably the port number is used - let's assume there already is a chat server.
      return false;
    }
    final ServerSocket _serverSocket = serverSocket;

    Thread thread = new Thread() { public void run() {
     try {
      while (true) {
        try {
          final Socket s = _serverSocket.accept();
          print("connect - clients: " + dialogServer_clients.incrementAndGet());
          Thread _t_1 = new Thread() {
public void run() {
try {

            try {
              final Writer w = new OutputStreamWriter(s.getOutputStream(), "UTF-8");
              final BufferedReader in = new BufferedReader(
                new InputStreamReader(s.getInputStream(), "UTF-8"));
              DialogIO io = new DialogIO() {
                String line;
                boolean buff;
                
                Socket getSocket() { return s; }
                
                // local means localhost - todo: test
                boolean isLocalConnection() {
                  return s.getInetAddress().isLoopbackAddress();
                }
                
                boolean isStillConnected() {
                  return !(buff || s.isClosed());
                }
                
                String readLineNoBlock() {
                  String l = line;
                  line = null;
                  return l;
                }
                
                boolean waitForLine() { try {
 
                  if (line != null) return true;
                  //print("Readline");
                  line = in.readLine();
                  //print("Readline done: " + line);
                  if (line == null) buff = true;
                  return line != null;
                
} catch (Throwable __e) { throw __e instanceof RuntimeException ? (RuntimeException) __e : new RuntimeException(__e); }}
                
                void sendLine(String line) { try {
 
                  w.write(line + "\n");
                  w.flush();
                
} catch (Throwable __e) { throw __e instanceof RuntimeException ? (RuntimeException) __e : new RuntimeException(__e); }}
              };
              
              try {
                handler.run(io);
              } finally {
                s.close();
              }
            } finally {
              print("client disconnect - " + dialogServer_clients.decrementAndGet() + " remaining");
            }
          } catch (Exception _e) {
  throw _e instanceof RuntimeException ? (RuntimeException) _e : new RuntimeException(_e); } }
};
_t_1.start();
        } catch (SocketTimeoutException e) {
        }
      }   
     } catch (IOException e) { throw new RuntimeException(e); }  
    }};
    if (daemon) thread.setDaemon(true);
    thread.start();
   
    print("Dialog server on port " + port + " started."); 
    return true;
  }

  static class Matches { String[] m; }
  
  static boolean match3(String pat, String s) {
    return match3(pat, s, null);
  }
  
  static boolean match3(String pat, String s, Matches matches) {
    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 List<String> parse3(String s) {
    return dropPunctuation(javaTokPlusPeriod(s));
  }

static DialogIO talkTo(String ip, int port) { try {
 
  print("Talking to " + ip + ":" + port);
  final Socket s = new Socket(ip, port);    

  final Writer w = new OutputStreamWriter(s.getOutputStream(), "UTF-8");
  final BufferedReader in = new BufferedReader(new InputStreamReader(s.getInputStream(), "UTF-8"));
  return new DialogIO() {
    String line;
    boolean buff;
    
    boolean isLocalConnection() {
      return s.getInetAddress().isLoopbackAddress();
    }
    
    boolean isStillConnected() {
      return !(buff || s.isClosed());
    }
    
    String readLineNoBlock() {
      String l = line;
      line = null;
      return l;
    }
    
    boolean waitForLine() { try {
 
      if (line != null) return true;
      //print("Readline");
      line = in.readLine();
      //print("Readline done: " + line);
      if (line == null) buff = true;
      return line != null;
    
} catch (Throwable __e) { throw __e instanceof RuntimeException ? (RuntimeException) __e : new RuntimeException(__e); }}
    
    void sendLine(String line) { try {
 
      w.write(line + "\n");
      w.flush();
    
} catch (Throwable __e) { throw __e instanceof RuntimeException ? (RuntimeException) __e : new RuntimeException(__e); }}
    
    void close() { try {
 
      s.close();
    
} catch (Throwable __e) { throw __e instanceof RuntimeException ? (RuntimeException) __e : new RuntimeException(__e); }}
    
    Socket getSocket() {
      return s;
    }
  };

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

// actually it's now almost the same as jsonDecode :)
static Object unstructure(String text) {
  final List<String> tok = javaTok(text);
  
  class X {
    int i = 1;

    Object parse() {
      String t = tok.get(i);
      if (t.startsWith("\"")) {
        String s = unquote(tok.get(i));
        i += 2;
        return s;
      }
      if (t.equals("{"))
        return parseMap();
      if (t.equals("["))
        return parseList();
      if (t.equals("null")) {
        i += 2; return null;
      }
      if (t.equals("false")) {
        i += 2; return false;
      }
      if (t.equals("true")) {
        i += 2; return true;
      }
      if (isInteger(t)) {
        i += 2; return Long.parseLong(t);
      }
      if (isJavaIdentifier(t)) {
        Class c = findClass(t);
        Object o = nuObject(c);
        i += 2;
        if (i < tok.size() && tok.get(i).equals("(")) {
          consume("(");
          while (!tok.get(i).equals(")")) {
            // It's like parsing a map.
            String key = unquote(tok.get(i));
            i += 2;
            consume("=");
            Object value = parse();
            set(o, key, value);
            if (tok.get(i).equals(",")) i += 2;
          }
          consume(")");
        }
        return o;
      }
      throw new RuntimeException("Unknown token " + (i+1) + ": " + t);
    }
    
    Object parseList() {
      consume("[");
      List list = new ArrayList();
      while (!tok.get(i).equals("]")) {
        list.add(parse());
        if (tok.get(i).equals(",")) i += 2;
      }
      consume("]");
      return list;
    }
    
    Object parseMap() {
      consume("{");
      Map map = new TreeMap();
      while (!tok.get(i).equals("}")) {
        String key = unquote(tok.get(i));
        i += 2;
        consume("=");
        Object value = parse();
        map.put(key, value);
        if (tok.get(i).equals(",")) i += 2;
      }
      consume("}");
      return map;
    }
    
    void consume(String s) {
      if (!tok.get(i).equals(s)) {
        String prevToken = i-2 >= 0 ? tok.get(i-2) : "";
        String nextTokens = join(tok.subList(i, Math.min(i+4, tok.size())));
        fail(quote(s) + " expected: " + prevToken + " " + nextTokens + " (" + i + "/" + tok.size() + ")");
      }
      i += 2;
    }
  }
  
  return new X().parse();
}

static Matcher matcher(String pattern, String string) {
  return Pattern.compile(pattern).matcher(string);
}

static Class __javax;

static Class getJavaX() {
  return __javax;
}

static String randomID(int length) {
  return makeRandomID(length);
}

static Object process(String processorID, Object in) {
  return process(processorID, in, "in");
}

static Object process(String processorID, Object in, String outVar) {
  try {
    Class processor = hotwire(processorID);
    set(processor, "in", in);
    call(processor, "main", new Object[] {new String[0]});
    return get(processor, outVar);
  } catch (Exception e) {
    throw new RuntimeException("Error in #" + parseSnippetID(processorID), e);
  }
}

static String _computerID;
public static String computerID() throws IOException {
  if (_computerID == null) {
    File file = new File(userHome(), ".tinybrain/computer-id");
    _computerID = loadTextFile(file.getPath(), null);
    if (_computerID == null) {
      _computerID = makeRandomID(12);
      saveTextFile(file.getPath(), _computerID);
    }
  }
  return _computerID;
}

static String structure(Object o) {
  return structure(o, 0);
}
  
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) {
    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 "{" + buf + "}";
  }

  if (o instanceof String)
    return quote(stringSizeLimit != 0 ? shorten((String) o, stringSizeLimit) : (String) o);
  
  // 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\\$", "");

  // TODO: go to superclasses too
  Field[] fields = o.getClass().getDeclaredFields();
  int numFields = 0;
  String fieldName = "";
  for (Field field : fields) {
    if ((field.getModifiers() & Modifier.STATIC) != 0)
      continue;
    Object value;
    try {
      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)
    b = b.replaceAll("^" + fieldName + "=", ""); // drop field name if only one
  String s = shortName;
  if (buf.length() != 0)
    s += "(" + b + ")";
  return s;
}

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

// currently finds only inner classes of class "main"
// returns null on not found
// this is the simple version that is not case-tolerant
static Class findClass(String name) {
  try {
    return Class.forName("main$" + name);
  } catch (ClassNotFoundException e) {
    return null;
  }
}

static Object nuObject(Class c, Object... args) { try {
 
  Constructor m = nuObject_findConstructor(c, args);
  m.setAccessible(true);
  return m.newInstance(args);

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

static Constructor nuObject_findConstructor(Class c, Object... args) {
  for (Constructor m : c.getDeclaredConstructors()) {
    if (!nuObject_checkArgs(m.getParameterTypes(), args, false))
      continue;
    return m;
  }
  throw new RuntimeException("Constructor with " + args.length + " matching parameter(s) not found in " + c.getName());
}

 static boolean nuObject_checkArgs(Class[] types, Object[] args, boolean debug) {
    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 <A> List<A> synchroList() {
  return Collections.synchronizedList(new ArrayList<A>());
}

static <A> List<A> synchroList(List<A> l) {
  return Collections.synchronizedList(l);
}


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

// 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, "*");
  int expand = 0;
  while (pat.size() < tok.size()) {
    ++expand;
    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()]);
}


// javaTok extended with "..." token.

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 is not needed in rest of loop body
    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)));
    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
      ++j;

    tok.add(s.substring(i, j));
    i = j;
  }
  
  if ((tok.size() % 2) == 0) tok.add("");
  return tok;
}


// replacement for class JavaTok
// maybe incomplete, might want to add floating point numbers
// todo also: extended multi-line strings

static List<String> javaTok(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 is not needed in rest of loop body
    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)));
    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
      ++j;

    tok.add(s.substring(i, j));
    i = j;
  }
  
  if ((tok.size() % 2) == 0) tok.add("");
  return tok;
}


  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;
          }
          i++;
        }
        sb.append(ch);
      }
      return sb.toString();      
    } else
      return s; // return original
  }

  // compile JavaX source, load classes & return main class
  // src can be a snippet ID or actual source code
  
  static Class<?> hotwire(String src) {
    try {
      Class j = getJavaX();

      List<File> libraries = new ArrayList<File>();
      File srcDir = (File) call(j, "transpileMain", src, libraries);
      
      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);

      return theClass;
    } catch (Exception e) {
      throw e instanceof RuntimeException ? (RuntimeException) e : new RuntimeException(e);
    }
  }

  static RuntimeException fail() {
    throw new RuntimeException("fail");
  }
  
  static RuntimeException fail(String msg) {
    throw new RuntimeException(msg);
  }

static String shorten(String s, int max) {
  return s.length() <= max ? s : s.substring(0, Math.min(s.length(), max)) + "...";
}
}
interface StrF {
  String get(String s);
}

Began life as a copy of #676