!636
!quickmain
!auto-import
!standard functions
!quicknew
!1000346 // use "case" as a variable name
!688 // buf.isEmpty
!class JavaTok
!1000381 // L<S>
!697 // "*()" constructor syntax, v2
!ctex
!719 // fill innerClasses

import java.lang.reflect.*;
import java.math.*; // BigInteger
import java.text.DecimalFormat;
import java.lang.management.*; // for time measurement

!include #1000451 // class _x18 modified for Android

interface Function {
  public Object process(Object in);
  public void toJava_process(Code code);
}

interface ReversibleFunction extends Function {
  public Object unprocess(Object in);
  public void toJava_unprocess(Code code);
}

// generic learner (works on objects)
interface Learner {
  public void processInOut(Object in, Object out);
  public Object processIn(Object in);
  public void toJava(Code code);
  public void tryAgain();
}

abstract class Base {
  void printVars() {
    new StringBuilder buf;
    Field[] fields = getClass().getDeclaredFields();
    for (Field field : fields) {
      if ((field.getModifiers() & Modifier.STATIC) != 0)
        continue;
      Object value;
      try {
        value = field.get(this);
      } catch (Exception e) {
        value = "?";
      }
      
      if (!buf.isEmpty()) buf.append(", ");
      buf.append(field.getName() + "=" + value);
    }
    System.out.println(buf.toString());
  }
}

abstract class LearnerImpl extends Base implements Learner {
  public void tryAgain() {
    throw new RuntimeException("No try again");
  }
  
  public void toJava(Code code) {
    main.todo();
  }
}

class Code {
  new StringBuilder buf;
  String var = "in";
  String indent = "";
  new List<String> translators;
  new List<String> varStack;
  int varCounter;
  
  *() {
    translators.add("!636");
  }
  
  void line(String line) {
    buf.append(indent).append(line).append('\n');
  }
  
  void indent() {
    indent += "  ";
  }
  
  void unindent() {
    indent = indent.substring(0, indent.length()-2);
  }
  
  void translators(String... ids) {
    for (String id : ids)
      if (! translators.contains(id)) // space is needed otherwise translator 636 is fooled :)
        translators.add(id);
  }
  
  String getTranslators() {
    // TODO: We should really fix the "standard functions" translator
    // to properly find the main class.
    //
    // As a hack, we move it upwards (before classes adding)
    int i = translators.indexOf("!standard functions");
    if (i >= 0) {
      translators.remove(i);
      translators.add(0, "!standard functions");
    }
    
    return main.fromLines(translators);
  }

  String s() {
    return "((String) " + var + ")";
  }
  
  String list() {
    return "((List) " + var + ")";
  }
  
  void assign(String exp) {
    line(var + " = " + exp + ";");
  }
  
  void newVar() {
    varStack.add(var);
    var = "_v" + (++varCounter);
    line("Object " + var + ";");
  }
  
  void oldVar() {
    var = varStack.get(varStack.size()-1);
    varStack.remove(varStack.size()-1);
  }
}

main {
  static Object androidContext;
  
  static final String ALL = "#681";
  
  static new List<Case> cases;
  static new HashMap<String, Case> casesByID;
  static boolean testJava = false, showFails, execTasks = false;
  static boolean collectClosest = false; // saves time
  static new (Hash)Set<String> parseErrors;
  static int caseIdx;
  static new (Hash)Set<Class> debuggedClasses;
  static String strategy = "#1000464";
  static String[] innerClasses;
  static new List<Throwable> strategyParseErrors;

  psvm {
    _x18.androidContext = androidContext;
    long startTime = System.currentTimeMillis();
    
    new List<String> snippetIDs;
    new List<String> inputs;
    
    for (int i = 0; i < args.length; i++) {
      String arg = args[i];
      if (arg.equals("debug"))
        debugOn(args[++i]);
      else if (arg.equals("in")) {
        String in = args[++i];
        System.out.println("in=" + quote(in));
        String quoteUnquote = unquote("\"" + in + "\"");
        System.out.println("now in=" + quote(quoteUnquote));
        inputs.add(quoteUnquote);
      } else if (arg.equals("-notestjava"))
        testJava = false;
      else if (arg.equals("-testjava"))
        testJava = true;
      else if (arg.equals("-withexec"))
        execTasks = true;
      else if (arg.equals("-showfails"))
        showFails = true;
      else if (arg.equals("strategy"))
        strategy = args[++i];
      else if (arg.equals("all"))
        snippetIDs.add(ALL);
      else if (isSnippetID(arg))
        snippetIDs.add(arg);
      else
        System.err.println("Unknown argument: " + arg + ", ignoring");
    }
    
    if (snippetIDs.isEmpty())
      if (parse(null) == null)
        parse(ALL);
    
    for (String snippetID : snippetIDs)
      try {
        Case case = parse(snippetID);
        case.halfExamples.addAll(inputs);
      } catch (Throwable e) {
        e.printStackTrace();
        parseErrors.add(snippetID);
      }
    
    int solved = 0, n = cases.size(), goodJava = 0;
    for (caseIdx = 0; caseIdx < n; caseIdx++) {
      Case case = cases.get(caseIdx);
      try {
        calculate(case);
      } catch (Throwable e) {
        e.printStackTrace();
      }
      if (case.winner != null)
        ++solved;
      if (case.goodJava)
        ++goodJava;
      if (caseIdx+1 == solved)
        System.out.println((caseIdx+1) + " case(s) processed & solved.");
      else
        System.out.println((caseIdx+1) + " case(s) processed, " + solved + " solved.");
      if (testJava && goodJava < solved)
        System.out.println((solved-goodJava) + " case(s) with BAD JAVA.");
    }

    print ""    
    print "----"

    List<Case> sorted = casesSortedByID();
    boolean allSolved = solved == n;
    if (solved != 0) {
      System.out.println();
      System.out.print("Solved: ");
      for (Case case : sorted)
        if (case.winner != null)
          System.out.print(case.id + " ");
      System.out.println();
    }
    if (testJava && solved > goodJava) {
      System.out.println();
      System.out.print("Bad Java: ");
      for (Case case : sorted)
        if (case.winner != null && !case.goodJava)
          System.out.print(case.id + " ");
      System.out.println();
    }
    if (!allSolved) {
      System.out.println();
      System.out.print("Unsolved: ");
      for (Case case : sorted)
        if (case.winner == null)
          System.out.print(case.id + " ");
      System.out.println();
    }
    if (!parseErrors.isEmpty()) {
      System.out.print("\nParse errors: ");
      for (String id : parseErrors)
          System.out.print(id + " ");
      System.out.println();
    }
    if (!strategyParseErrors.isEmpty())
      System.out.println("Strategy parse errors!");
    System.out.println();
    if (allSolved && testJava && goodJava < solved)
      System.out.println("ALL SOLVED (" + solved + "), but some BAD JAVA.");
    else {
      System.out.println(allSolved ? "ALL SOLVED (" + solved + ")" : "Solved " + solved + " out of " + n + ".");
      if (testJava)
        if (goodJava == solved)
          System.out.println("All Java code OK" + (allSolved ? "" : " (for solved cases)") + ".");
        else
          System.out.println("Some bad Java.");
      else
        System.out.println("Java not tested.");
    }
    print ""
    
    /*long time = getUserTime();
    if (time >= 0)
      System.out.println("User time: " + formatDouble(time/1e9, 3) + "s");*/
      
    long time = System.currentTimeMillis()-startTime;
    System.out.println("Real time: " + formatDouble(time/1e3, 3) + "s");
  }
  
  public static String formatDouble(double d, int digits) {
    String format = "0.";
    for (int i = 0; i < digits; i++) format += "#";
    String s = new DecimalFormat(format).format(d);
    return s.replace(',', '.'); // hack german -> english
  }
  
  /** Get user time in nanoseconds. */
  public static long getUserTime( ) {
    ThreadMXBean bean = ManagementFactory.getThreadMXBean();
    return bean.isCurrentThreadCpuTimeSupported() ?
      bean.getCurrentThreadUserTime() : -1L;
  }
  
  static class Case {
    String id;
    new List<String[]> fullExamples;
    new List<String> halfExamples;
    List<String[]> examples1, examples2;
    Learner winner;
    RunnersUp runnersUp = collectClosest ? new RunnersUp() : null;
    boolean goodJava;
    List<Case> combined;
    int splitPoint = -1;
    
    // stats
    int learnersTried, retries;

    void split() {    
      if (examples1 != null)
        return; // already done
      if (fullExamples.size() < 2)
        throw new RuntimeException("Too few examples (" + fullExamples.size() + ")");
      if (splitPoint < 0)
        splitPoint = fullExamples.size()-1;
      System.out.println("Full examples: " + fullExamples.size() + ", splitPoint: " + splitPoint + ", half examples: " + halfExamples.size());
      examples1 = fullExamples.subList(0, splitPoint);
      examples2 = fullExamples.subList(splitPoint, fullExamples.size());
    }
    
    void add(Case case) {
      combined.add(case);
      fullExamples.addAll(case.fullExamples);
      halfExamples.addAll(case.halfExamples);
    }
    
    Object processIn(Object in) {
      return winner.processIn(in);
    }
  }

  static Case parse(String arg) tex {
   try {
    new Case case;
    String text;
    if (arg != null) {
      if (casesByID.containsKey(arg))
        return casesByID.get(arg);
        
      if (arg.startsWith("Combine")) {
        case.id = "Combine";
        case.combined = new ArrayList<Case>();
        List<String> tok = JavaTok.split(arg);
        new List<String> ids;
        for (int i = 5; i < tok.size(); i += 6) { // skip # and "and"
          Case case2 = parse("#" + tok.get(i));
          case.id += " #" + tok.get(i);
          cases.remove(case2);
          case.add(case2);
        }
        addCase(case);
        return case;
      } else if (isSnippetID(arg)) {
        case.id = arg;
        text = loadSnippet(arg);
      } else {
        case.id = "direct";
        text = arg;
      }
    } else {
      case.id = "input.txt";
      text = loadTextFile("input/input.txt", null);
      if (text == null) return null;
    }
    
    // it's a collection of cases!
    if (text.trim().startsWith("#") || text.trim().startsWith("Combine")) {
      for (String line : toLines(text))
        parse(line);
      return null;
    }
    
    // it's a "Continue:" task - transform to I/O format
    if (text.trim().startsWith("Continue:")) {
      List<String> lines = toLines(text);
      new StringBuilder buf;
      for (int i = 1; i < lines.size(); i++) {
        buf.append("In: " + quote("" + i) + "\n");
        buf.append("Out: " + quote(lines.get(i)) + "\n");
      }
      int numAsking = 3;
      for (int i = lines.size(); i < lines.size()+numAsking; i++)
        buf.append("In: " + quote("" + i) + "\n");
      text = buf.toString();
    }
      
    // it's an "Execute." task - run Java(X) and transform to I/O format
    if (text.trim().startsWith("Execute.")) {
      if (!execTasks) return null;
      List<String> tok = JavaTok.split(text);
      new StringBuilder buf;
      for (int i = 5; i < tok.size(); i += 2) {
        if (tok.get(i).equals("-") && tok.get(i+2).equals("-")) {
          i += 2;
          buf.append("--\n");
        } else {
          String code = unquote_fixSpaces(tok.get(i));
          String result = execute("!636\n" + code);
          buf.append("In: " + quote(code) + "\n");
          buf.append("Out: " + quote(result) + "\n");
        }
      }
      text = buf.toString();
    }

    if (text.trim().startsWith("Marking.")) {
      
      List<String> tok = JavaTok.split(text);
      new StringBuilder buf;
      for (int i = 5; i < tok.size(); i += 2) {
        if (tok.get(i).equals("-") && tok.get(i+2).equals("-")) {
          i += 2;
          buf.append("--\n");
        } else {
          String out = unquote_fixSpaces(tok.get(i));
          String in = out.replace("[[", "").replace("]]", "");
          buf.append("In: " + quote(in) + "\n");
          buf.append("Out: " + quote(out) + "\n");
        }
      }
      text = buf.toString();
    }
 
    System.out.println(text);
    String in = null, out = null;
    
    List<String> tok = JavaTok.split(text);
    for (int i = 1; i < tok.size(); i += 2) {
      String t = tok.get(i), t2 = i+2 < tok.size() ? tok.get(i+2) : "";
      if (t.equals("-") && t2.equals("-")) {
        i += 2;
        case.splitPoint = case.fullExamples.size();
        //System.out.println("t=" + t + ", t2= " + t2);
      } else if (t.toUpperCase().startsWith("I") && t2.equals("-") && tok.get(i+4).toUpperCase().equals("DOC") && tok.get(i+6).equals(":")) { // "In-Doc:"
        if (in != null)
          case.halfExamples.add(in);
        i += 8;
        int j = findNextLine(tok, i);
        String inID = unquote_fixSpaces(JavaTok.join(tok.subList(i, j-1)));
        in = loadSnippet(inID);
        i = j-2;
        out = null;
      } else if (t.toUpperCase().startsWith("I") && t2.equals(":")) { // "In:" or "I:"
        if (in != null)
          case.halfExamples.add(in);
        i += 4;
        int j = findNextLine(tok, i);
        in = unquote_fixSpaces(JavaTok.join(tok.subList(i, j-1)));
        i = j-2;
        out = null;
      } else if (t.toUpperCase().startsWith("O") && t2.equals(":")) { // "Out: " or "O: "
        i += 4;
        int j = findNextLine(tok, i);
        out = unquote_fixSpaces(JavaTok.join(tok.subList(i, j-1)));
        i = j-2;
        if ((in + out).indexOf('\t') >= 0)
          System.err.println("WARNING: Tab character used!");
        System.out.println(quote(in) + " => " + quote(out));
        case.fullExamples.add(new String[] {in, out});
        in = out = null;
      } else {
        int j = findNextLine(tok, i);
        String line = JavaTok.join(tok.subList(i, j-1));
        i = j-2;
        System.out.println("-- Ignoring line: " + line);
      }
    }
    
    if (in != null)
      case.halfExamples.add(in);
    addCase(case);
    return case;
   } catch (Throwable e) {
    parseErrors.add(arg);
    e.printStackTrace();
    return null;
   }
  }
  
  static String unquote_fixSpaces(String s) {
    String _ = unquote(s);
    if (s.startsWith("[["))
      _ = fixSpaces(_);
    return _;
  }
  
  // remove invisible spaces at end of line - this will otherwise confuse the engine(s) greatly...
  static String fixSpaces(String s) {
    System.out.println(quote(s));
    s = s.replaceAll("[\t ]+(\r?\n)", "$1");
    s = s.replaceAll("[\t ]+$", "");
    //System.out.println("_fixSpaces => " + quote(s));
    return s;
  }
  
  // i is a code-token (odd index)
  // return value is also a code token, or end of list
  static int findNextLine(List<String> tok, int i) {
    while (i < tok.size() && tok.get(i-1).indexOf('\n') < 0)
      i += 2;
    return i;
  }
  
  static void addCase(Case case) {
    cases.add(case);
    casesByID.put(case.id, case);
  }
  
  static void calculate(Case case) tex {
    System.out.println("\n== CASE " + case.id + " ==");
    
    case.split();
    Learner learner = findOKLearner(case);
    if (learner == null) {
      String stat = "";
      if (case.retries != 0) stat = " + " + case.retries + " retries";
      System.out.println("\nProblem not solved (" + case.learnersTried + " learners tried" + stat + ")");
      RunnersUp ru = case.runnersUp;
      if (ru != null && ru.winner != null)
        System.out.println("Closest result: " + quote(ru.bestResult) + " instead of " + quote(ru.expected) + " (score " + ru.bestScore + ") by " + structure(ru.winner));
    } else {
      print "\nSolved!"
      print("  " + structure(learner) + "\n");
      case.winner = learner;
      new Code code;
      if (testJava) try {
        learner.toJava(code);

        if (testJava)
          testJava(case, code); // prints "GOOD JAVA" or "BAD JAVA"
        else
          print "Java:"
          
        System.out.println(indent("  ", code.getTranslators()));
        System.out.println(indent("  ", code.buf.toString()));
      } catch (Throwable e) {
        print "BAD JAVA"
      }
        
      for (String in : case.halfExamples) {
        Object out = learner.processIn(in);
        System.out.println(quote(in) + " =>! " + quote((String) out));
      }
    }
  }

  static void choice_orderList(List l) {
  }
  
  static Learner findOKLearner(Case case) tex {
    List<Learner> list = makeLearners();
    choice_orderList(list);
    for (Learner learner : list) try {
      if (learnerOK(learner, case))
        return learner;
    } catch (Throwable e) {
      if (showFails)
        e.printStackTrace();
    }
    
    if (case.combined != null) {
      Case switchCase = makeSwitchCase(case);
      calculate(switchCase);
      Learner learner = switchCase.winner;
      if (learner != null)
        return new LSwitch(case, learner);
    }
    
    return null;
  }
  
  static Case makeSwitchCase(Case case) {
    int i = 0;
    Case s = new Case();
    s.id = "Switch " + case.id;
    s.examples1 = new ArrayList<String[]>();
    s.examples2 = new ArrayList<String[]>();
    for (Case c : case.combined) {
      ++i;
      for (String[] e : c.examples1)
        s.examples1.add(new String[] {e[0], String.valueOf(i)});
      for (String[] e : c.examples2)
        s.examples2.add(new String[] {e[0], String.valueOf(i)});
      for (String[] e : c.fullExamples)
        s.fullExamples.add(new String[] {e[0], String.valueOf(i)});
    }
    return s;
  }
  
  static boolean learnerOK(Learner learner, Case case) {
    String[] _e = null;
    try {
      if (case.examples1 == null)
        fail("Case not calculated: " + case.id);
        
      ++case.learnersTried;
      for (String[] e : case.examples1) {
        _e = e;
        learner.processInOut(e[0], e[1]);
      }
      
      // full validation against all examples - but starting with the unknown ones to make coding easier for learners
      int retry = 0;
      retryLoop: while (true) {
        int n = case.fullExamples.size();
        for (int i = 0; i < n; i++) {
          String[] e = case.fullExamples.get((i+case.examples1.size()) % n);
          _e = e;
          String out = (String) learner.processIn(e[0]);
          if (!e[1].equals(out)) {
          
            if (case.runnersUp != null)
              case.runnersUp.add(e[1], out, leven(out, e[1]), learner);
              
            if (showFails)
              System.out.println("[fail] " + structure(learner) + " on " + quote(e[0]) + " - got: " + quote(out) + " rather than: " + quote(e[1]));
            ++retry;
            ++case.retries;
            if (retry % 1000 == 0)
              System.err.println("Retry " + retry);
            learner.tryAgain();
            continue retryLoop;
          }
        }
        return true;  // all test examples passed
      }
    } catch (Throwable e) {
      if (debuggedClasses.contains(learner.getClass()) || showFails) {
        e.printStackTrace();
        System.err.println("[fail] " + structure(learner) + " on " + (_e == null ? "?" : quote(_e[0])) + " - " + e);
      }
      return false;
    }
  }
  
  static boolean validate(String[] example, Learner learner) {
    try {
      String out = (String) learner.processIn(example[0]);
      if (!example[1].equals(out)) {
          //System.out.println("[fail] " + learner + " on " + quote(e[0]) + " - got: " + quote(out) + " rather than: " + quote(e[1]));
          return false;
        }
      return true;
    } catch (Throwable e) {
      silentException(e);
      return false;
    }
  }
  
  static void silentException(Throwable e) {
  }
  
  static List<Learner> makeLearners() ctex {
    return parseStrategy(loadSnippet(strategy));
  }
  
  /* XXX - important part */
  static List<Learner> parseStrategy(String strategyText) ctex {
    List <String> lines = toLines(strategyText);
    new List<Learner> list;
    for (String s : lines) try {
      s = s.trim();
      String[] parts = s.split(" +");
      if (parts.length == 0) continue;
      
      new Stack<Object> stack;
      for (int i = parts.length-1; i >= 0; i--) {
        String p = parts[i];
        Class c = findClassFlex(p);
        if (c == null)
          fail("Strategy element " + p + " not known");
        
        Constructor ctr = c.getDeclaredConstructors()[0];
        Class[] types = ctr.getParameterTypes();
        if (types.length == 0)
          stack.add(ctr.newInstance());
        else if (types.length == 1)
          stack.add(ctr.newInstance(stack.pop()));
        else
          fail("bla");
        
        /*if (isSubclass(c, ReversibleFunction.class)) {
          l = new LWrap((ReversibleFunction) newInstance(c), l);
          continue;
        }*/
      }
      
      list.add((Learner) stack.peek());
    } catch (Throwable e) {
      System.err.println("Strategy parse error.");
      e.printStackTrace();
      strategyParseErrors.add(e);
    }
    return list;
  }

  static List<Learner> makeLearnersX() {
    new List<Learner> list;
    list.addAll(level1());
    list.add(new LBox(new LMulti(level1())));
    list.add(new LBox2(new LMulti(level1())));
    
    list.add(new LChange(new FCommonPrefix(), new LOutPattern()));
    list.add(new LChange(new FCommonSuffix(), new LOutPattern()));
    
    list.add(new LEmptyBox(new LMulti(level1())));
    
    list.add(new LChange(new RFToLines(), new LFixedFunction(new FLength())));
    
    // for #1000455
    list.add(new LFindOutInIn(new LFixedSubstring()));
   
    for (int I = 1; I <= 2; I++)
    // for #1000457
    list.add(new LChange(new FDropFirstLines(I), new LMulti(
      new LFixWhitespace(l1()), level1())));

    // for #1000458
    list.add(new LFixWhitespace(l1()));

    return list;
  }

  static Learner l1() {
    return new LMulti(level1());
  }
  
  static List<Learner> level1() {
    new List<Learner> list;
    list.add(new LId()); // always good to have as included learner
    list.add(new LPrefixSuffix());
    list.add(new LSplitInput(new LOutPattern()));
    list.add(new LInputPattern());
    list.add(new LFixed());
    list.add(new LWrap(new RFJavaTok(), new LEach(new LFixedFunction(new EscapeCase()))));
    list.add(new LCharShift());
    list.add(new LOutSuffix(new LFirst(new LCharShift())));
    
    list.add(new LChange(new RFJavaTok(), new LMulti(
      new LChange(new FStringsOnly(), new LGetListElement()),
      new LChange(new FNumbersOnly(), new LMath()))
    ));
    
    // TODO - for #1000378
    list.add(new LChange(new RFJavaTok(), new LDistinguishList(new FIsString())));
    
    list.add(new LFixedSubstring());
    
    // of no use now it seems
    // list.add(new LTryPrevious());
    
    return list;
  }
  
  public static String unquote(String s) {
    if (s.startsWith("[[") && s.endsWith("]]"))
      return s.substring(2, s.length()-2);
    else if (s.startsWith("\"") && s.endsWith("\"") && s.length() > 1)
      //return s.substring(1, s.length()-1).replace("\\\"", "\"").replace("\\\\", "\\");
      return unescapeJavaString(s.substring(1, s.length()-1));
    else
      return s; // return original
  }
  
  /** from: http://stackoverflow.com/questions/3537706/howto-unescape-a-java-string-literal-in-java,
      or: https://gist.github.com/uklimaschewski/6741769
      
      Thanks!
  */
  public static String unescapeJavaString(String st) {
    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();
  }
  
  static String indent(String indent, String s) {
    return indent + s.replace("\n", "\n" + indent);
  }
  
  static Class<?> getClass(String name) {
    try {
      return Class.forName(name);
    } catch (ClassNotFoundException e) {
      return null;
    }
  }
  
  static void debugOn(String name) {
    try {
      Class c = findClassFlex(name);
      debuggedClasses.add(c);
      Field field;
      while (true)
        try {
          field = c.getDeclaredField("debug");
          break;
        } catch  (NoSuchFieldException e) {
          c = c.getSuperclass();
        }
      field.setBoolean(null, true);
    } catch (Exception e) {
      e.printStackTrace();
      System.err.println("Cannot debug class " + name);
    }
  }

static int choice(String text, int i) {
  return i;
}
  
  // splits the input at some point, takes only one part
  static class LSplitInput extends LearnerImpl {
    int splitIdx = 1; // split after first character
    Learner baseLearner;
    
    LSplitInput(Learner baseLearner) {
      this.baseLearner = baseLearner;
      splitIdx = choice("LSplitInput.i", splitIdx);
    }
    
    public void processInOut(Object _in, Object _out) {
      String in = (String) _in, out = (String) _out;
      in = in.substring(splitIdx);
      baseLearner.processInOut(in, out);
    }
    
    public Object processIn(Object _in) {
      String in = (String) _in;
      in = in.substring(splitIdx);
      return baseLearner.processIn(in);
    }
    
    public void toJava(Code code) {
      if (splitIdx != 0)
        code.line(code.var + " = ((String) " + code.var + ").substring(" + splitIdx + ");");
      baseLearner.toJava(code);
    }
  }

  static class FDropFirstLines implements Function {
    int n;
    *(int *n) {}

    public Object process(Object _in) {
      String in = (String)_in;
      for (int I=0; I < n; I++)
        in = in.substring(in.indexOf('\n')+1);
      return in;
    }
    
    public void toJava_process(Code code) {
      todo();
    }
  }
  
  // removes common suffix from out, delegates to base learner
  static class LOutSuffix extends LearnerImpl {
    String suffixOut = "";
    Learner baseLearner;
    
    LOutSuffix(Learner baseLearner) {
      this.baseLearner = baseLearner;
    }
    
    public void processInOut(Object _in, Object _out) {
      String in = (String) _in, out = (String) _out;
      if (out.endsWith("!"))
        suffixOut = "!";
      if (out.endsWith(suffixOut))
        out = out.substring(0, out.length()-suffixOut.length());
      
      baseLearner.processInOut(in, out);
    }
    
    public Object processIn(Object _in) {
      String in = (String) _in;
      return baseLearner.processIn(in) + suffixOut;
    }
    
    public void toJava(Code code) {
      baseLearner.toJava(code);
      if (suffixOut.length() != 0)
        code.line(code.var + " = " + code.s() + "+" + quote(suffixOut) + ";");
    }
  }
  
  // if input appears in output in fixed pattern
  static class LOutPattern extends LearnerImpl {
    static boolean debug;
    String pattern = "%!%";

    public void processInOut(Object _in, Object _out) {
      String in = (String) _in, out = (String) _out;
      pattern = out.replace(in, "%!%");
      if (debug)
        System.out.println("LOutPattern: in=" + quote(in) + ", out=" + quote(out) + ", pattern=" + quote(pattern));
    }
    
    public String processIn(Object _in) {
      String in = (String) _in;
      return pattern.replace("%!%", in);
    }
    
    public void toJava(Code code) {
      code.line(code.var + " = " + quote(pattern) + ".replace(" + quote("%!%") + ", (String) " + code.var + ");");
    }
  }
  
  // simplets learner - only knows the "id" function
  static class LId extends LearnerImpl {
    public void processInOut(Object in, Object out) {
    }
    
    public Object processIn(Object in) {
      return in;
    }
    
    public void toJava(Code code) {
    }
  }
  
  // learns to exchange common prefixes and suffixes
  static class LPrefixSuffix extends LearnerImpl {
    static boolean debug;
    String prefixIn, suffixIn, prefixOut, suffixOut;
    
    public void processInOut(Object _in, Object _out) {
      String in = (String) _in, out = (String) _out;
      updateIn(in);
      prefixOut = prefixOut == null ? out : commonPrefix(prefixOut, out);
      suffixOut = suffixOut == null ? out : commonSuffix(suffixOut, out);
      if (debug)
        printState("processInOut(" + quote(in) + ", " + quote(out) + ")");
    }
    
    void updateIn(String in) {
      prefixIn = prefixIn == null ? in : commonPrefix(prefixIn, in);
      suffixIn = suffixIn == null ? in : commonSuffix(suffixIn, in);
      if (debug)
        printState("updateIn(" + quote(in) + ")");
    }

    public String processIn(Object _in) {
      String in = (String) _in;
      //System.out.println("[before last info] " + quote(prefixIn) + " " + quote(suffixIn) + " " + quote(prefixOut) + " " + quote(suffixOut));
      //System.out.println("[last info] " + quote(in));
      
      // use latest information
      String p = prefixIn, s = suffixIn;
      updateIn(in);
      prefixOut = prefixOut.substring(0, prefixOut.length()-(p.length()-prefixIn.length()));
      suffixOut = suffixOut.substring(s.length()-suffixIn.length());
      
      //System.out.println("[after last info] " + quote(prefixIn) + " " + quote(suffixIn) + " " + quote(prefixOut) + " " + quote(suffixOut));
      String core = in.substring(prefixIn.length(), in.length()-suffixIn.length());
      return prefixOut + core + suffixOut;
    }
    
    public void toJava(Code code) {
      if (prefixIn.length() != 0 || suffixIn.length() != 0)
        code.line(code.var + " = ((String) " + code.var + ").substring(" + prefixIn.length() + ", " + code.s() + ".length()-" + suffixIn.length() + ");");
      if (prefixOut.length() != 0 || suffixOut.length() != 0)
        code.line(code.var + " = " + quote(prefixOut) + " + " + code.var + " + " + quote(suffixOut) + ";");
    }
    
    void printState(String text) {
      System.out.println(text);
      printVars();
    }
  }
  
  // for "find" tasks (e.g. "abcde" to "[[abc]]de")
  static class LInputPattern extends LearnerImpl {
    String regexp = "", findMarker1 = "[[", findMarker2 = "]]";
    
    public void processInOut(Object _in, Object _out) {
      String in = (String) _in, out = (String) _out;
      int i = out.indexOf(findMarker1), j = out.indexOf(findMarker2, i+1);
      if (j < 0) return;
      String s = out.substring(i+2, j);
      regexp = s.replaceAll("\\d+", Matcher.quoteReplacement("\\d+"));
      System.out.println("regexp: " + regexp);
    }
    
    public String processIn(Object _in) {
      String in = (String) _in;
      if (regexp.length() == 0)
        return in;
      else
        return in.replaceAll("(" + regexp + ")", findMarker1 + "$1" + findMarker2);
    }
    
    public void toJava(Code code) {
      code.line(code.var + " = ((String) " + code.var + ").replaceAll(" + quote("(" + regexp + ")") + ", \"[[$1]]\");");
    }
  }
  
  static class LFixed extends LearnerImpl {
    static boolean debug;
    Object value;
    
    public void processInOut(Object in, Object out) {
      value = out;
      if (debug)
        printVars();
    }
    
    public Object processIn(Object in) {
      return value;
    }
    
    public void toJava(Code code) {
      code.line(code.var + " = " + quote((String) value) + ";");
    }
  }
  
  static void fail() {
    throw new RuntimeException("fail");
  }
  
  static void fail(String msg) {
    throw new RuntimeException(msg);
  }
  
  static void assertSameSize(List a, List b) {
    if (a.size() != b.size())
      fail("wrong list sizes");
  }

  // process lists in parallel
  // (in and out must be a list of same length)
  static class LEach extends LearnerImpl {
    static boolean debug;
    Learner base;
    
    LEach(Learner base) {
      this.base = base;
    }
    
    public void processInOut(Object _in, Object _out) {
      List in = (List) _in, out = (List) _out;
      assertSameSize(in, out);
      for (int i = 0; i < in.size(); i++)
        base.processInOut(in.get(i), out.get(i));
      if (debug)
        printVars();
    }
    
    public Object processIn(Object _in) {
      List in = (List) _in;
      List out = new ArrayList();
      for (Object x : in)
        out.add(base.processIn(x));
      return out;
    }
    
    public void toJava(Code code) {
      code.line("List out = new ArrayList();");
      code.line("for (Object x : (List) in) {");
      code.indent();
      code.line("in = x;");
      base.toJava(code);
      code.line("out.add(in);");
      code.unindent();
      code.line("}");
      code.line("in = out;");
    }
  }
  
  static class LChange extends LearnerImpl {
    Function f;
    Learner base;
    
    LChange(Function f, Learner base) {
      this.f = f;
      this.base = base;
    }
    
    public void processInOut(Object in, Object out) {
      in = f.process(in);
      base.processInOut(in, out);
    }
    
    public Object processIn(Object in) {
      in = f.process(in);
      return base.processIn(in);
    }
    
    public void toJava(Code code) {
      f.toJava_process(code);
      base.toJava(code);
    }
  }
  
  static class LFindOutInIn extends LearnerImpl {
    static boolean debug;
    Learner base;
    String findMarker1 = "{{", findMarker2 = "}}";
    
    *(Learner *base) {}
    
    public void processInOut(Object _in, Object _out) {
      String in = (String) _in, out = (String) _out;
      if (out.length() == 0)
        out = in;
      else {
        int i = in.indexOf(out);
        if (i < 0) throw new RuntimeException("error");
        int j = i+out.length();
        out = in.substring(0, i) + findMarker1 + in.substring(i, j) + findMarker2 + in.substring(j);
        if (debug)
          System.out.println("LFindOutInIn: index=" + i);
      }
      
      base.processInOut(in, out);
      
      if (debug)
        System.out.println("LFindOutInIn: Base learned. " + base);
    }
    
    public Object processIn(Object _in) {
      if (debug)
        System.out.println("LFindOutInIn: processIn");
      String in = (String) _in;
      String out = (String) base.processIn(in);
      int i = out.indexOf(findMarker1), j = out.indexOf(findMarker2, i)-2;
      String result = i < 0 ? "" : in.substring(i, j);
      if (debug)
        System.out.println("LFindOutInIn: processIn " + i + " " + j + " " + quote(result));
      return result;
    }
    
    public void tryAgain() {
      base.tryAgain();
    }
  }
  
  static class LWrap extends LearnerImpl {
    ReversibleFunction f;
    Learner base;
    
    LWrap(ReversibleFunction f, Learner base) {
      this.f = f;
      this.base = base;
    }
    
    public void processInOut(Object in, Object out) {
      in = f.process(in);
      out = f.process(out);
      base.processInOut(in, out);
    }
    
    public Object processIn(Object in) {
      in = f.process(in);
      in = base.processIn(in);
      in = f.unprocess(in);
      return in;
    }
    
    public void toJava(Code code) {
      f.toJava_process(code);
      base.toJava(code);
      f.toJava_unprocess(code);
    }
  }
  
  static class RFJavaTok implements ReversibleFunction {
    public Object process(Object in) {
      return JavaTok.split((String) in);
    }
    
    public Object unprocess(Object in) {
      return JavaTok.join((List) in);
    }
    
    public void toJava_process(Code code) {
      code.translators("!636", "!class JavaTok");
      code.line(code.var + " = JavaTok.split((String) " + code.var + ");");
    }
    
    public void toJava_unprocess(Code code) {
      code.translators("!636", "!class JavaTok");
      code.line(code.var + " = JavaTok.join((List) " + code.var + ");");
    }
  }
  
  static class RFToLines implements ReversibleFunction {
    public Object process(Object in) {
      return toLines((String) in);
    }
    
    public Object unprocess(Object in) {
      return fromLines((List) in);
    }
    
    public void toJava_process(Code code) {
      code.translators("!636", "!standard functions");
      code.assign("toLines(" + code.s() + ");");
    }
    
    public void toJava_unprocess(Code code) {
      code.translators("!636", "!standard functions");
      code.assign("fromLines(" + code.list() + ");");
    }
  }
  
  // works on a token list - makes a list of only the string constants (unquoted)
  static class FStringsOnly implements Function {
    static boolean debug;
    
    public Object process(Object _in) {
      new List<String> tok;
      for (String s : (List<String>) _in) {
        boolean isString = s.startsWith("\"") || s.startsWith("[[");
        if (isString)
          tok.add(unquote(s));
        if (debug)
          System.out.println("FStringsOnly - isString: " + isString + " - " + s);
      }
      return tok;
    }
    
    public void toJava_process(Code code) {
      code.translators("!standard functions");
      code.line("List<String> tok = new ArrayList<String>();");
      code.line("for (String s : (List<String>) " + code.var + ")");
      code.line("  if (s.startsWith(\"\\\"\") || s.startsWith(\"[[\")) tok.add(unquote(s));");
      code.assign("tok");
    }
  }
  
  // works on a token list - makes a list of only the number constants
  static class FNumbersOnly implements Function {
    static boolean debug;
    
    public Object process(Object _in) {
      new List<String> tok;
      for (String s : (List<String>) _in) {
        boolean isNumber = s.length() != 0 && (Character.isDigit(s.charAt(0)) || (s.charAt(0) == '-' && s.length() > 1));
        if (isNumber)
          tok.add(s);
        if (debug)
          System.out.println("FNumbersOnly - isNumber: " + isNumber + " - " + s);
      }
      return tok;
    }
    
    public void toJava_process(Code code) {
      code.line("List<String> tok = new ArrayList<String>();");
      code.line("for (String s : (List<String>) " + code.var + ")");
      code.line("  if (s.length() != 0 && (Character.isDigit(s.charAt(0)) || (s.charAt(0) == '-' && s.length() > 1))) tok.add(s);");
      code.assign("tok");
    }
  }
  
  static class FLength implements Function {
    static boolean debug;
    
    public Object process(Object in) {
      Object result = String.valueOf(in instanceof List ? ((List) in).size() : ((String) in).length());
      if (debug)
        System.out.println("FLength: " + result);
      return result;
    }
    
    public void toJava_process(Code code) {
      code.assign("String.valueOf(" + code.var + " instanceof List ? " + code.list() + ".size() : " + code.s() + ".length())");
    }
  }
  
  static class LFixedFunction extends LearnerImpl {
    Function f;
    
    LFixedFunction(Function f) {
      this.f = f;
    }
    
    public void processInOut(Object in, Object out) {
    }
    
    public Object processIn(Object in) {
      return f.process(in);
    }
    
    public void toJava(Code code) {
      f.toJava_process(code);
    }
  }
  
  // trivial stuff like taking the one element out of a 1-element list
  static class LTrivial extends LearnerImpl {
    public void processInOut(Object in, Object out) {
    }
    
    public Object processIn(Object in) {
      return ((List) in).get(0);
    }
    
    public void toJava(Code code) {
      code.assign(code.list() + ".get(0)");
    }
  }
  
  // get element of a list at fixed index
  static class LGetListElement extends LearnerImpl {
    static boolean debug;
    int i;
    
    public void processInOut(Object _in, Object out) {
      List in = (List) _in;
      i = in.indexOf(out);
      if (debug)
        System.out.println("LGetListElement: " + i + " " + out);
    }
    
    public Object processIn(Object in) {
      return ((List) in).get(i);
    }
    
    public void toJava(Code code) {
      code.assign(code.list() + ".get(" + i + ")");
    }
  }
  
  // math operations
  static class LMath extends LearnerImpl {
    static boolean debug;
    String allOperations = "+ - * /";
    new (Tree)Set<String> possibleOperations;
    
    LMath() {
      possibleOperations.addAll(Arrays.asList(allOperations.split(" +")));
    }
    
    public void processInOut(Object _in, Object _out) {
      List in = (List) _in;
      String out = (String) _out;
      BigInteger[] inNumbers = getNumbers(in);
      BigInteger[] outNumbers = new BigInteger[] {getNumber(out)};
      findOperation(inNumbers, outNumbers);
      if (debug)
        System.out.println("Operations: " + possibleOperations);
    }
    
    public void findOperation(BigInteger[] in, BigInteger[] out) {
      filterOperations(in, out);
      if (possibleOperations.isEmpty())
        fail("tilt");
    }
      
    public void filterOperations(BigInteger[] in, BigInteger[] out) {
      for (Iterator<String> i = possibleOperations.iterator(); i.hasNext(); ) {
        String op = i.next();
        BigInteger[] out2 = doOperation(op, in);
        if (out2 == null || !arraysEqual(out, out2))
          i.remove(); // keep only matching operations
      }
    }
    
    public BigInteger[] doOperation(String op, BigInteger[] in) {
      op = op.intern();
      try {
        if (in.length == 2) {
          BigInteger a = in[0], b = in[1], x = null;
          if (op == "+")
            x = a.add(b);
          else if (op == "-")
            x = a.subtract(b);
          else if (op == "*")
            x = a.multiply(b);
          else if (op == "/")
            x = a.divide(b);
          return x != null ? new BigInteger[] {x} : null;
        }
        return null;
      } catch (Throwable e) {
        return null;
      }
    }
    
    public String processIn(Object _in) {
      List<String> in = (List<String>) _in;
      String op = possibleOperations.iterator().next();
      if (debug)
        System.out.println("op: " + op);
      BigInteger[] inNumbers = getNumbers(in);
      BigInteger[] outNumbers = doOperation(op, inNumbers);
      return outNumbers[0].toString();
    }
    
    String BI = BigInteger.class.getName();
    
    public void toJava(Code code) {
      String op = possibleOperations.iterator().next();
      String a = "new " + BI + "((String) " + code.list() + ".get(0))";
      String b = "new " + BI + "((String) " + code.list() + ".get(1))";
      if (op.equals("+"))
        code.assign(a + ".add(" + b + ").toString()");
      else
        todo();
    }
    
    static BigInteger[] getNumbers(List<String> in) {
      BigInteger[] big = new BigInteger[in.size()];
      for (int i = 0; i < in.size(); i++)
        big[i] = new BigInteger(in.get(i));
      return big;
    }
    
    static BigInteger getNumber(String s) {
      return new BigInteger(s);
    }
    
    static boolean arraysEqual(BigInteger[] a, BigInteger[] b) {
      if (a.length != b.length) return false;
      for (int i = 0; i < a.length; i++)
        if (!a[i].equals(b[i])) return false;
      return true;
    }
  }
  
  static class EscapeCase implements Function {
    static boolean debug;
    
    public Object process(Object _in) {
      if (debug)
        System.out.println("EscapeCase: " + _in);
      String in = (String) _in;
      return in.equals("case") ? "_case" : in;
    }
    
    public void toJava_process(Code code) {
      code.line("if (\"case\".equals(" + code.var + ")) " + code.var + " = " + quote("_case") + ";");
    }
  }
  
  static class LCharShift extends LearnerImpl {
    int shift;
    
    public void processInOut(Object _in, Object _out) {
      String in = (String) _in, out = (String) _out;
      shift = (int) out.charAt(0) - (int) in.charAt(0);
    }
    
    public Object processIn(Object _in) {
      String in = (String) _in;
      char[] c = new char[in.length()];
      for (int i = 0; i < c.length; i++)
        c[i] = (char) ((int) in.charAt(i) + shift);
      return new String(c);
    }
    
    public void toJava(Code code) {
      code.line("char[] c = new char[((String) " + code.var + ").length()];");
      code.line("for (int i = 0; i < c.length; i++)");
      code.line("  c[i] = (char) ((int) ((String) " + code.var + ").charAt(i)" + (shift < 0 ? "" + shift : "+" + shift) + ");");
      code.line(code.var + " = new String(c);");
    }
  }
  
  // applies base learner to first char of string
  // (or first element of list, TODO)
  static class LFirst extends LearnerImpl {
    Learner baseLearner;
    
    *(Learner baseLearner) {
      this.baseLearner = baseLearner;
    }
    
    public void processInOut(Object _in, Object _out) {
      String in = (String) _in, out = (String) _out;
      if (in.length() == 0)
        return;
      String firstIn = in.substring(0, 1), firstOut = out.substring(0, 1);
      baseLearner.processInOut(firstIn, firstOut);
    }
    
    public Object processIn(Object _in) {
      String in = (String) _in;
      if (in.length() == 0)
        return in;
      String firstIn = in.substring(0, 1);
      return baseLearner.processIn(firstIn) + in.substring(1);
    }
    
    public void toJava(Code code) {
      code.line("if (" + code.s() + ".length() != 0) {");
      code.indent();
      code.line("String rest = " + code.s() + ".substring(1);");
      code.line(code.var + " = " + code.s() + ".substring(0, 1);");
      baseLearner.toJava(code);
      code.line(code.var + " = " + code.s() + "+rest;");
      code.unindent();
      code.line("}");
    }
  }
  
  static Method findMainMethod(Class<?> theClass) {
    for (Method method : theClass.getMethods())
      if (method.getName().equals("main") && method.getParameterTypes().length == 1)
        return method;
    throw new RuntimeException("Method 'main' with 1 parameter not found in " + theClass.getName());
  }
  
  // compile JavaX source and load main class
  static Class<?> compileAndLoadMainClass(String src) tex {
    File srcDir = _x18.TempDirMaker_make();
    File classesDir = _x18.TempDirMaker_make();
    _x18.saveTextFile(new File(srcDir, "main.java").getPath(), src);
    new List<File> libraries;
    File transpiledDir = _x18.topLevelTranslate(srcDir, libraries);
    String javacOutput = _x18.compileJava(transpiledDir, libraries, classesDir);
    System.out.println(javacOutput);
    URL[] urls = {classesDir.toURI().toURL()};
    
    // make class loader
    URLClassLoader classLoader = new URLClassLoader(urls);

    // load main class
    Class<?> mainClass = classLoader.loadClass("main");
    return mainClass;
  }
      
  static Method compileJavaInToOut(Code code) {
    try {
      String java = code.buf.toString();
      String prelude = /*"import java.util.*;\n\n" +*/
        "public class main { public static Object main(Object in) throws Exception {\n";
      String postlude = "\nreturn in;\n}}";
      String src = code.getTranslators() + "\n" + prelude + java + postlude;
      Class<?> mainClass = compileAndLoadMainClass(src);
      return findMainMethod(mainClass);
    } catch (Exception e) {
      throw new RuntimeException(e);
    }
  }
  
  static Method findCalcMethod(Class<?> theClass) {
    for (Method method : theClass.getMethods())
      if (method.getName().equals("calc"))
        return method;
    throw new RuntimeException("Method 'calc' not found in " + theClass.getName());
  }
  
  // for simplejava stuff (execute tasks)
  static String execute(String src) {
    try {
      Class<?> mainClass = compileAndLoadMainClass(src);
      Method m = findCalcMethod(mainClass);
      return String.valueOf(m.invoke(null));
    } catch (Exception e) {
      throw new RuntimeException(e);
    }
  }
  
  static void testJava(Case case, Code code) {
    try {
      Method m = compileJavaInToOut(code);
      
      for (String[] e : case.fullExamples) {
        String out = (String) m.invoke(null, e[0]);
        
        if (!e[1].equals(out)) {
          throw new RuntimeException("[fail] Java code on " + quote(e[0]) + " - got: " + quote(out) + " rather than: " + quote(e[1]));
        }
      }
      
      System.out.println("\nGOOD JAVA.");
      case.goodJava = true;
    } catch (Throwable e) {
      if (showFails)
        e.printStackTrace();
      System.out.println("\nBAD JAVA.");
    }
  }
  
  static void todo() {
    fail("todo");
  }
  
  static class LSwitch extends LearnerImpl {
    Case case;
    Learner switcher;
    
    *(Case case, Learner switcher) {
      this.case = case;
      this.switcher = switcher;
    }
    
    public void processInOut(Object in, Object out) {
    }
   
    public Object processIn(Object in) {
      int i = Integer.parseInt((String) switcher.processIn(in));
      return case.combined.get(i-1).winner.processIn(in);
    }
   
    public void toJava(Code code) {
      todo();
    }
  }
 
  static class LTryPrevious extends LearnerImpl {
    new List<Case> candidates;
    
    *() {
      for (int i = caseIdx-1; i >= 0; i--)
        candidates.add(cases.get(i));
    }

    public void processInOut(Object _in, Object _out) {
      String in = (String) _in, out = (String) _out;
      for (ListIterator<Case> i = candidates.listIterator(); i.hasNext(); ) {
        Case case = i.next();
        if (case.winner == null || !validate(new String[] {in, out}, case.winner))
          i.remove();
      }
      if (candidates.isEmpty())
        fail("no previous solution found");
    }
  
    public Object processIn(Object in) {
      return candidates.get(0).winner.processIn(in);
    }
  
    public void toJava(Code code) {
      candidates.get(0).winner.toJava(code);
    }
  }
  
  static class LMulti extends LearnerImpl {
    static boolean debug;
    new List<Learner> candidates;
    
    *(Learner... learners) {
      for (Learner l : learners)
        candidates.add(l);
    }
    
    *(L<Learner> learners) {
      for (Learner l : learners)
        candidates.add(l);
    }

    *(Learner l, L<Learner> ll) {
       candidates.add(l);
      candidates.addAll(ll);
    }
    
    public void processInOut(Object in, Object out) {
      if (debug)
        System.err.println("LMulti candidates: " + candidates.size());
      for (ListIterator<Learner> i = candidates.listIterator(); i.hasNext(); ) {
        Learner l = i.next();
        try {
          l.processInOut(in, out);
        } catch (Throwable e) {
          if (debug) {
            e.printStackTrace();
            System.err.println("Removing candidate: " + structure(l));
          }
          silentException(e);
          i.remove();
        }
      }
      if (debug)
        System.err.println("LMulti candidates now: " + candidates.size());
      if (candidates.isEmpty())
        fail("no candidates left");
    }
    
    public Object processIn(Object in) {
      while (true) { // fails or returns eventually
        Learner l = candidates.get(0);
        if (debug)
          System.err.println("Using candidate: " + structure(l) + ", " + candidates.size() + " left");
        try {
          return l.processIn(in);
        } catch (Throwable e) {
          if (debug) {
            e.printStackTrace();
            System.err.println("Removing candidate: " + structure(l));
          }
          silentException(e);
          candidates.remove(0);
        }
      }
    }
    
    public void tryAgain() {
      candidates.remove(0);
    }
    
    public void toJava(Code code) {
      candidates.get(0).toJava(code);
    }
  }
  
  static String structure(Object o) {
    if (o == null) return "null";
    String name = o.getClass().getName();
    
    new StringBuilder buf;
    
    if (o instanceof Collection) {
      for (Object x : (Collection) o) {
        if (!buf.isEmpty()) buf.append(", ");
        buf.append(structure(x));
      }
      return "{" + buf + "}";
    }

    if (o instanceof String)
      return quote((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();
    for (Field field : fields) {
      if ((field.getModifiers() & Modifier.STATIC) != 0)
        continue;
      Object value;
      try {
        value = field.get(o);
      } catch (Exception e) {
        value = "?";
      }
      
      String fieldName = field.getName();
      
      // special case for LMulti - show only first (current) candidate
      if (shortName.equals("LMulti") && field.getName().equals("candidates")) {
        fieldName = "candidate";
        value = ((List) value).isEmpty() ? value : ((List) value).get(0);
      }
        
      if (value != null) {
        if (!buf.isEmpty()) buf.append(", ");
        buf.append(fieldName + "=" + structure(value));
      }
    }
    String s = shortName;
    if (!buf.isEmpty())
      s += "(" + buf + ")";
    return s;
  }
  
  static class FIsString implements Function {
    static boolean debug;
    
    public Object process(Object _in) {
      String in = (String) _in;
      return in.startsWith("\"") || in.startsWith("[[") ? "1" : "0";
    }
    
    public void toJava_process(Code code) {
      code.assign(code.s() + ".startsWith(\"\\\"\") || " + code.s() + ".startsWith(\"[[\") ? \"1\" : \"0\"");
    }
  }
  
  static class FCommonPrefix implements Function {
    static boolean debug;

    public Object process(Object _in) {
      String in = (String) _in, prefix = null;
      for (String line : toLines(in))
        if (line.length() != 0) {
          prefix = prefix == null ? line : commonPrefix(prefix, line);
          if (debug)
            System.out.println("FCommonPrefix: line=" + quote(line) + ", prefix=" + quote(prefix));
        }
      return prefix;
    }
    
    public void toJava_process(Code code) {
      todo();
    }
  }
  
  static class FCommonSuffix implements Function {
    static boolean debug;

    public Object process(Object _in) {
      String in = (String) _in, suffix = null;
      for (String line : toLines(in))
        if (line.length() != 0) {
          suffix = suffix == null ? line : commonSuffix(suffix, line);
          if (debug)
            System.out.println("FCommonSuffix: line=" + quote(line) + ", suffix=" + quote(suffix));
        }
      return suffix;
    }
    
    public void toJava_process(Code code) {
      todo();
    }
  }
  
  /*static class Pair {
    Object a, b;
    
    public boolean equals(Object o) {
      return o instanceof Pair && a.equals(((Pair) o).a) && b.equals((Pair) o).b);
    }
    
    public int hashCode() {
      return a.hashCode()+b.hashCode()*2;
    }
  }*/
  
  static class Matrix {
    new HashMap<Object, Map> dataByCol;
    
    void put(Object col, Object row, Object value) {
      //data.put(new Pair(col, row), value);
      getCol(col).put(row, value);
    }
    
    Map getCol(Object col) {
      Map map = dataByCol.get(col);
      if (map == null)
        dataByCol.put(col, map = new HashMap());
      return map;
    }
    
    Object get(Object col, Object row) {
      //return data.get(new Pair(col, row));
      return getCol(col).get(row);
    }
    
    Set cols() {
      return dataByCol.keySet();
    }
    
    Set rowsFor(Object col) {
      return getCol(col).keySet();
    }
  }
  
  static class LDistinguishList extends LearnerImpl {
    static boolean debug;
    Function helper;
    int idx;
    new Matrix matrix;

    *(Function helper) {
      this.helper = helper;
    }
    
    public void processInOut(Object _in, Object out) {
      List in = (List) _in;
      for (int i = 0; i < in.size(); i++) {
        Object y = helper.process(in.get(i));
        matrix.put(i, y, out);
      }
    }
    
    public Object processIn(Object _in) {
      // find idx
      
      for (Object i : matrix.cols()) {
        Collection ys = matrix.rowsFor(i);
        if (ys.size() > 1) {
          idx = (Integer) i;
          break;
        }
      }
      
      List in = (List) _in;
      Object y = helper.process(in.get(idx));
      return matrix.get(idx, y);
    }
    
    public void toJava(Code code) {
      List ys = new ArrayList(matrix.rowsFor(idx));
      //String v = code.var;
      //code.newVar();
      //String vy = code.var;
      //code.oldVar();
      code.assign(code.list() + ".get(" + idx + ")");
      helper.toJava_process(code);
      
      for (int i = 0; i < ys.size(); i++) {
        Object y = ys.get(i);
        if (i < ys.size())
          code.line((i == 0 ? "" : "else ") + "if (" + quote((String) y) + ".equals(" + code.var + "))");
        else
          code.line("else");
        code.line("  " + code.var + " = " + quote((String) matrix.get(idx, y)) + ";");
      }
    }
  }
  
  static class RunnersUp {
    String expected;
    int bestScore = -1;
    String bestResult;
    Learner winner;
    
    void add(String expected, String result, int score, Learner learner) {
      if (!expected.equals(this.expected) || bestScore == -1 || score < bestScore) {
        bestScore = score;
        bestResult = result;
        winner = learner;
      }
      this.expected = expected;
    }
  }
  
  static List<Case> casesSortedByID() {
    new (Tree)Map<Long, Case> map;
    new List<Case> rest;
    for (Case c : cases)
      if (isSnippetID(c.id))
        map.put(parseSnippetID(c.id), c);
      else
        rest.add(c);
    List<Case> list = new ArrayList<Case>(map.values());
    list.addAll(rest);
    return list;
  }
  
  !include #1000388 // leven (Levenshtein distance function)
  
  !include #1000382 // Box learners
  !include #1000387 // Empty box learner
  
  // for "find" tasks (e.g. "abcde" to "[[abc]]de")
  static class LFixedSubstring extends LearnerImpl {
    static boolean debug;
    String findMarker1 = "{{", findMarker2 = "}}";
    int i, j;
    
    public void processInOut(Object _in, Object _out) {
      String in = (String) _in, out = (String) _out;
      i = out.indexOf(findMarker1);
      j = out.indexOf(findMarker2, i)-2;
      if (debug && j >= 0) {
        boolean correct = in.substring(i, j).equals(out.substring(i+2, j+2));
        System.out.println("LFixedSubstring: i, j = " + i + ", " + j + " " + correct + " " + quote(in.substring(i, j)));
      }
    }
    
    public String processIn(Object _in) {
      String in = (String) _in;
      return in.substring(0, i) + findMarker1 + in.substring(i, j) + findMarker2 + in.substring(j);
    }
  }

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

  !include #1000459 // LFixWhiteSpace

  static Object newInstance(Class c, Object... args) ctex {
    Constructor m = findConstructor(c, args);
    m.setAccessible(true);
    return m.newInstance(args);
  }
  
  static Constructor findConstructor(Class c, Object[] args) {
    for (Constructor m : c.getDeclaredConstructors()) {
      if (!checkArgs(m.getParameterTypes(), args, false))
        continue;
      return m;
    }
    throw new RuntimeException("Constructor with " + args.length + " matching parameter(s) not found in " + c.getName());
  }
  
  static Class findClass(String name) ctex {
    for (String c : innerClasses)
      if (c.equalsIgnoreCase(name))
        return Class.forName("main$" + c);
    return null;
  }
  
  static boolean isSubclass(Class a, Class b) {
    return b.isAssignableFrom(a);
  }
  
  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 || types[i].isInstance(args[i]))) {
        if (debug)
          System.out.println("Bad parameter " + i + ": " + args[i] + " vs " + types[i]);
        return false;
      }
    return true;
  }
  
  !include #1000465 // LCertainElement
  
  static Class findClassFlex(String p) {
    Class c = findClass(p);
    if (c == null) c = findClass("L" + p);
    if (c == null) c = findClass("F" + p);
    if (c == null) c = findClass("RF" + p);
    return c;
  }
  
  !include #1000468 // LOneWordChanged
  !include #1000470 // LBla
}

Began life as a copy of #716