anchor.diff:      if ((y < 0) || (y > cols - 1))
         return;
   
  -    if (uiState[y][x] == clearedCell)
  -      return;
  -    uiState[y][x] = clearedCell;
  +    if (uiState[y][x] == CellState.cleared)
  +      return;
  +    uiState[y][x] = CellState.cleared;
   
       if (mineCount(x, y) > 0)
         return;
  
positive.code: import 'package:sky/rendering/flex.dart';
  import 'package:sky/theme/colors.dart' as colors;
  import 'package:sky/widgets/basic.dart';
  import 'package:sky/widgets/scaffold.dart';
  import 'package:sky/widgets/task_description.dart';
  import 'package:sky/widgets/theme.dart';
  import 'package:sky/widgets/tool_bar.dart';
  
  // Classic minesweeper-inspired game. The mouse controls are standard except
  // for left + right combo which is not implemented. For touch, the duration of
  // the pointer determines probing versus flagging.
  //
  // There are only 3 classes to understand. Game, which is contains all the
  // logic and two UI classes: CoveredMineNode and ExposedMineNode, none of them
  // holding state.
  
  class Game {
    static const int rows = 9;
    static const int cols = 9;
    static const int totalMineCount = 11;
  
    static const int coveredCell = 0;
    static const int explodedCell = 1;
    static const int clearedCell = 2;
    static const int flaggedCell = 3;
    static const int shownCell = 4;
  
    static final List<TextStyle> textStyles = new List<TextStyle>();
  
    final App app;
  
    bool alive;
    bool hasWon;
    int detectedCount;
    int randomSeed;
  
    // |cells| keeps track of the positions of the mines.
    List<List<bool>> cells;
    // |uiState| keeps track of the visible player progess.
    List<List<int>> uiState;
  
    Game(this.app) {
      randomSeed = 22;
      // Colors for each mine count:
      // 0 - none, 1 - blue, 2-green, 3-red, 4-black, 5-dark red .. etc.
      textStyles.add(
        new TextStyle(color: const Color(0xFF555555), fontWeight: bold));
      textStyles.add(
        new TextStyle(color: const Color(0xFF0094FF), fontWeight: bold));
      textStyles.add(
        new TextStyle(color: const Color(0xFF13A023), fontWeight: bold));
      textStyles.add(
        new TextStyle(color: const Color(0xFFDA1414), fontWeight: bold));
      textStyles.add(
        new TextStyle(color: const Color(0xFF1E2347), fontWeight: bold));
      textStyles.add(
        new TextStyle(color: const Color(0xFF7F0037), fontWeight: bold));
      textStyles.add(
        new TextStyle(color: const Color(0xFFE93BE9), fontWeight: bold));
      initialize();
    }
  
    void initialize() {
      alive = true;
      hasWon = false;
      detectedCount = 0;
      // Build the arrays.
      cells = new List<List<bool>>();
      uiState = new List<List<int>>();
      for (int iy = 0; iy != rows; iy++) {
        cells.add(new List<bool>());
        uiState.add(new List<int>());
        for (int ix = 0; ix != cols; ix++) {
          cells[iy].add(false);
          uiState[iy].add(coveredCell);
        }
      }
      // Place the mines.
      Random random = new Random(++randomSeed);
      for (int mc = 0; mc != totalMineCount; mc++) {
        int rx = random.nextInt(rows);
        int ry = random.nextInt(cols);
        if (cells[ry][rx]) {
          // Mine already there. Try again.
          --mc;
        } else {
          cells[ry][rx] = true;
        }
      }
    }
  
    Widget buildBoard() {
      bool hasCoveredCell = false;
      List<Flex> flexRows = new List<Flex>();
      for (int iy = 0; iy != 9; iy++) {
        List<Component> row = new List<Component>();
        for (int ix = 0; ix != 9; ix++) {
          int state = uiState[iy][ix];
          int count = mineCount(ix, iy);
  
          if (!alive) {
            if (state != explodedCell)
              state = cells[iy][ix] ? shownCell : state;
          }
  
          if (state == coveredCell) {
            row.add(new CoveredMineNode(
              this,
              flagged: false,
              posX: ix, posY: iy));
              // Mutating |hasCoveredCell| here is hacky, but convenient, same
              // goes for mutating |hasWon| below.
              hasCoveredCell = true;
          } else if (state == flaggedCell) {
            row.add(new CoveredMineNode(
              this,
              flagged: true,
              posX: ix, posY: iy));
          } else {
            row.add(new ExposedMineNode(
              state: state,
              count: count));
          }
        }
        flexRows.add(
  
negative.code:     );
    }
  
    void handleToolbarPointerDown(sky.PointerEvent event) {
      setState(() {
        resetGame();
      });
    }
  
    // User action. The user uncovers the cell which can cause losing the game.
    void probe(int x, int y) {
      if (!alive)
        return;
      if (uiState[y][x] == CellState.flagged)
        return;
      setState(() {
        // Allowed to probe.
        if (cells[y][x]) {
          // Probed on a mine --> dead!!
          uiState[y][x] = CellState.exploded;
          alive = false;
        } else {
          // No mine, uncover nearby if possible.
          cull(x, y);
        }
      });
    }
  
    // User action. The user is sure a mine is at this location.
    void flag(int x, int y) {
      setState(() {
        if (uiState[y][x] == CellState.flagged) {
          uiState[y][x] = CellState.covered;
          --detectedCount;
        } else {
          uiState[y][x] = CellState.flagged;
          ++detectedCount;
        }
      });
    }
  
    // Recursively uncovers cells whose totalMineCount is zero.
  