!636
!quickmain
!auto-import

import java.math.*; // BigInteger

interface Learner {
  void processInOut(String in, String out);
  String processIn(String in);
}

main {
  psvm {
    print "\nHello. Teach me math."
    LMath learner = new LMath();
    while (true) {
      String in = readLine("\nQ: ");
      in = in.trim();
      
      if (in.equals("restart")) {
        System.out.println("[restart]");
        learner.restart();
        continue;
      }
      
      if (in.length() == 0)
        break;
      
      String guess = learner.processIn(in);
      if (guess != null && guess.length() != 0) {
        System.out.println(in + " => " + guess);
        String ok = readLine("\nOK (y/n)? ");
        ok = ok.toLowerCase().trim();
        boolean yes = ok.startsWith("y") || ok.startsWith("j");
        if (yes) {
          print ":)"
          // OPTIONAL - indicate that guess was OK: learner.processInOut(in, guess);
          continue;
        } else {
          print "Oops."
          // query correcting answer from user
        }
      } else {
        print "I don't know."
      }
      
      String out = readLine(in + " => ");
      out = out.trim();
      learner.processInOut(in, out);
      System.out.println("OK. " + in + " => " + out);
    }
  }
  
  static Scanner system_in = new Scanner(System.in);
  static String readLine(String prompt) {
    System.out.print(prompt);
    return system_in.nextLine();
  }
  
  static BigInteger[] getNumbers(String s) {
    Pattern p = Pattern.compile("-?\\d+");
	  Matcher m = p.matcher(s);
	  List<BigInteger> list = new ArrayList<BigInteger>();
	  while (m.find())
	    list.add(new BigInteger(m.group()));
	  return list.toArray(new BigInteger[list.size()]);
  }
  
  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 LMath implements Learner {
    String allOperations = "+ - * /";
    Set<String> possibleOperations = new TreeSet<String>();
    String outPattern = "";
    
    LMath() {
      restart();
    }
    
    void restart() {
      possibleOperations.addAll(Arrays.asList(allOperations.split(" +")));
    }
    
    public void processInOut(String in, String out) {
      outPattern = out.replaceAll("-?\\d+", "*");
      BigInteger[] inNumbers = getNumbers(in);
      BigInteger[] outNumbers = getNumbers(out);
      try {
        findOperation(inNumbers, outNumbers);
      } catch (Throwable e) {
        e.printStackTrace();
      }
    }
    
    public void findOperation(BigInteger[] in, BigInteger[] out) {
      filterOperations(in, out);
      if (possibleOperations.isEmpty()) {
        System.out.println("TILT");
        restart();
        filterOperations(in, out);
      }
    }
      
    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(String in) {
      if (possibleOperations.isEmpty()) return "";
      String op = possibleOperations.iterator().next();
      
      BigInteger[] inNumbers = getNumbers(in);
      BigInteger[] outNumbers = doOperation(op, inNumbers);
      String s = outPattern;
      if (outNumbers != null)
        for (BigInteger num : outNumbers)
          s = outPattern.replaceFirst("\\*", num.toString());
      return s;
    }
  }
}