anchor.diff:  
     void _performMove(Move move) {
       if (move.count > 1) {
  -      _compoundState = new _CompoundMoveState(move);
  -      _performCompoundMoveStep();
  +      CompoundMovePlanner planner = new CompoundMovePlanner(tableau);
  +      _compoundPlan = planner.plan(_planSimpleMove(move), move.count);
  +      _nextStepInCompoundPlan = 0;
  +      _performNextStepInCompoundPlan();
         return;
       }
   
  +    _executeSimplePlan(_planSimpleMove(move));
  +    _scheduleNextMove();
  +  }
  +
  +  Transfer _planSimpleMove(Move move) {
       Pile source = _sourcePile(move);
       Card card = source.cards.last;
       Pile destination = _destiniationPile(move, card);
  -
  -    _transferCard(card, source, destination);
  -    _scheduleNextMove();
  +    return new Transfer(source, destination);
     }
   
  -  void _scheduleCompoundMoveStep() {
  -    new Timer(_moveDelay, _performCompoundMoveStep);
  +  void _executeSimplePlan(Transfer transfer) {
  +    Card card = transfer.source.cards.last;
  +
  +    assert(transfer.source.canTake(card));
  +    assert(transfer.destination.canAccept(card));
  +
  +    _willRemoveFromPile(card);
  +    transfer.destination.accept(card);
  +    transfer.source.cards.remove(card);
     }
   
  -  void _performCompoundMoveStep() {
  -    Move move = _compoundState.move;
  -
  -    assert(move.count > 1);
  -    assert(move.sourceType == 'stack');
  -    assert(move.destinationType == 'stack');
  -
  -    Pile source = _sourcePile(move);
  -    Pile destination = _destiniationPile(move, null);
  -
  -    while (_compoundState.windStep < move.count - 1) {
  -      Card card = source.cards.last;
  -      Pile temporary = _findTempory(card, destination);
  -      _compoundState.temporaries.add(temporary);
  -      _transferCard(card, source, temporary);
  -      ++_compoundState.windStep;
  -      _scheduleCompoundMoveStep();
  +  void _performNextStepInCompoundPlan() {
  +    if (_nextStepInCompoundPlan >= _compoundPlan.length) {
  +      _compoundPlan = null;
  +      _nextStepInCompoundPlan = -1;
  +      _performNextMove();
         return;
       }
  -
  -    if (_compoundState.needsHeroStep) {
  -      _transferCard(source.cards.last, source, destination);
  -      _compoundState.needsHeroStep = false;
  -      _scheduleCompoundMoveStep();
  -      return;
  -    }
  -
  -    while (_compoundState.unwindStep < _compoundState.temporaries.length) {
  -      Pile temporary = _compoundState.temporaries[_compoundState.temporaries.length - _compoundState.unwindStep - 1];
  -      _transferCard(temporary.cards.last, temporary, destination);
  -      ++_compoundState.unwindStep;
  -      _scheduleCompoundMoveStep();
  -      return;
  -    }
  -
  -    _compoundState = null;
  -    _performNextMove();
  -  }
  -
  -  void _transferCard(Card card, Pile source, Pile destination) {
  -    assert(source.canTake(card));
  -    assert(destination.canAccept(card));
  -
  -    // _willRemoveFromPile(card);
  -    destination.accept(card);
  -    source.cards.remove(card);
  +    _executeSimplePlan(_compoundPlan[_nextStepInCompoundPlan++]);
  +    new Timer(_moveDelay, _performNextStepInCompoundPlan);
     }
   
     Pile _sourcePile(Move move) {
  
positive.code: 
  import "card-coordinator.dart";
  
  class _CompoundMoveState {
    Move move;
    List<Pile> temporaries = new List<Pile>();
    int windStep = 0;
    int unwindStep = 0;
    bool needsHeroStep = true;
  
    _CompoundMoveState(this.move);
  }
  
  class SolutionPlayer {
    static final _moveDelay = new Duration(milliseconds: 100);
  
    Tableau tableau;
    Solution solution;
    int _nextMove = 0;
    Completer _completer = new Completer();
    _CompoundMoveState _compoundState;
  
    SolutionPlayer(this.tableau, this.solution);
  
  
negative.code:     return null;
    }
  
    void _willRemoveFromPile(Card card) {
      CardCoordinator.instance.viewForCard(card).willRemoveFromPile();
    }
  