anchor.diff:          me = new Player(myBoard, score1, 0, turn);
           opp = new Player(oppBoard, score2, 0, turn);
   
  +        sw = new Stopwatch();
  +        sw.start();
  +        stderr.writeln("Reset Clock: ${sw.elapsedMilliseconds}");
  +        
           stderr.writeln("Upcoming: $pairs");
           printBoard(myBoard);
  +       
  +        //single depth ranking until depthEval works 
           Map rankMap = rankMoves(me);
           stderr.writeln("Rankmap $rankMap");
  -
           List<Move> bestMoves = rankMap[rankMap.keys.last];
  -
           Move move = bestMoves[rand.nextInt(bestMoves.length)];
  -
  -        print("${move.col} ${move.rot}");
  +        
  +        Solution sol = findSolution(me, opp, pairs.take(5).toList());
  +        Move solMove = sol.p1Moves.first;
  +        
  +        if(rankMap.keys.last > sol.p1Eval){
  +            stderr.writeln("Chose single-depth move $move");
  +            print("${move.col} ${move.rot}");
  +        } else {
  +            stderr.writeln("Chose solution move $solMove");
  +            print("${solMove.col} ${solMove.rot}");
  +        }
   
           turn++;
           turn++;
       }
  +}
  +
  +class Solution{
  +    Player p1Start;
  +    Player p2Start;
  +    Player p1End;
  +    Player p2End;
  +    List<Move> p1Moves;
  +    List<Move> p2Moves;
  +    List<Pair> pairs;
  +    
  +    int p1Death = -1;
  +    int p2Death = -1;
  +    
  +    num p1Nuisance = 0;
  +    num p2Nuisance = 0;
  +    
  +    num p1Eval = -1;
  +    num p2Eval = -1;
  +    
  +    num p1Discount;
  +    num p2Discount;
  +    
  +    Solution(this.p1Start, this.p2Start, this.pairs, this.p1Moves, this.p2Moves){
  +        p1End = p1Start.clone();
  +        p2End = p2Start.clone();
  +        p1Discount = p1Start.score;
  +        p2Discount = p2Start.score;
  +        applySolution();
  +    }
  +    
  +    void applySolution(){
  +        for(int index = 0; index < pairs.length && p1End.alive; index++){
  +            p1End = p1End.applyMove(p1Moves[index], pairs[index]);
  +            p1Discount += p1End.score * pow(.8, index);
  +            if(p1End.alive == false){
  +                p1Death = index;
  +            }
  +        }
  +        
  +        this.p1Eval = p1End.evaluate();
  +        if(p1Death > 0){
  +            this.p1Eval = -1000 + p1Death;
  +        }
  +        // stderr.writeln("Clock: ${sw.elapsedMilliseconds} After solution eval: ${p1Eval}");
  +        // stderr.writeln("After solution score: ${p1End.score}");
  +        // stderr.writeln("After solution board: ");
  +        // printBoard(p1End.board);
  +        
  +    }
  +    
   }
   
   class Player {
       List<List<Cell>> board = [];
       int score;
       num nuisancePoints;
  +    int turn;
       num generatedNuisance = 0;
       bool alive = true;
  -    int turn;
   
       Player(this.board, this.score, this.nuisancePoints, this.turn);
  +    
  +    Player clone(){
  +        List<List<Cell>> newBoard = new List.generate(6, (index) =>
  +            new List.from(this.board[index]));
  +        
  +        Player clone = new Player(newBoard, this.score, this.nuisancePoints, this.turn);
  +        clone.alive = this.alive;
  +        clone.generatedNuisance = this.generatedNuisance;
  +        
  +        return clone;
  +    }
   
       int get totalBlocks => board.fold(0, (prev, element) => prev + element.length);
  +    int get totalSkulls => board.fold(0, 
  +        (prev, element) => prev + 
  +        element.where((cell) => cell == Cell.skull).length);
   
       num evaluate(){
           if(!alive){
  
positive.code:         for(int col = 0; col < board[row].length; col++){
              Point cp = new Point(col, row);
              Cell current = board[row][col];
              List<Point> valids = validNeighbors(cp, board);
              if(current != Cell.empty &&
              current != Cell.skull &&
              valids.where((valid) => cellAt(board, valid) == current).length == 1){
  
negative.code:         acc.add(current);
          closed.add(current);
          //generate neighbors and recurse
          List<Point> valids = validNeighbors(board, current);
  
          for(Point valid in valids){
              if(!open.contains(valid) && !closed.contains(valid)){
  