anchor.diff:  
     void _performMove(Move move) {
       if (move.count > 1)
  -      throw "Oops, need fancier logic";
  +      return _performCompoundMove(move);
   
       Pile source = _sourcePile(move);
       Card card = source.cards.last;
       Pile destination = _destiniationPile(move, card);
   
  +    _transferCard(card, source, destination);
  +  }
  +
  +  void _performCompoundMove(Move move) {
  +    assert(move.count > 1);
  +    assert(move.sourceType == 'stack');
  +    assert(move.destinationType == 'stack');
  +
  +    Pile source = _sourcePile(move);
  +    Pile destination = _destiniationPile(move, null);
  +
  +    List<Cell> usedCells = new List<Cell>();
  +
  +    for (int i = 0; i < move.count - 1; ++i) {
  +      Card card = source.cards.last;
  +      Cell freeCell = _findFreeCell(card);
  +      usedCells.add(freeCell);
  +      _transferCard(card, source, freeCell);
  +    }
  +
  +    _transferCard(source.cards.last, source, destination);
  +
  +    for (int i = usedCells.length - 1; i >= 0; --i) {
  +      Cell cell = usedCells[i];
  +      _transferCard(cell.cards.last, cell, destination);
  +    }
  +  }
  +
  +  void _transferCard(Card card, Pile source, Pile destination) {
       assert(source.canTake(card));
       assert(destination.canAccept(card));
   
  
positive.code:     return null;
    }
  
    void _willRemoveFromPile(Card card) {
      CardCoordinator.instance.viewForCard(card).willRemoveFromPile();
    }
  
negative.code:   int _nextMove = 0;
    Completer _completer = new Completer();
  
    static final _moveDelay = new Duration(milliseconds: 500);
  
    SolutionPlayer(this.tableau, this.solution);
  
    Future play() {
      new Timer.periodic(_moveDelay, (timer) {
        if (_nextMove >= solution.moves.length) {
          timer.cancel();
          _completer.complete();
          return;
        }
  