srecord noeq GridCodec1(BufferedImage stage0_image) is JavaCodec<BufferedImage> {

  settable int rows = 20;

  static GridCodec1 demo() { ret GridCodec1(defaultScreenshot()); }

  // interim data & searches 

  Matrix<Int> stage1_matrix;

  long dataBytes, dataChars;

  Matrix<Matrix<Int>> stage2_grid;

  JE_CompressEachElementIndividually<LInt> strat;

  JECompressionSearch<LLInt> search;

  JECompressionSearch<LLInt> forward() {

    // go from stage 0 (image) to stage 3 (list of list of ints)

    assertNotNull(stage0_image);

    var m = stage1_matrix = imageToMatrix(stage0_image);

    dataBytes = m.nCells()*4+2;

    dataChars = dataBytes*2 + l("lInt(\"\")");

    print("Matrix ~ " + shorten_str(60, m));

    print("Trivial comp ~ " + (m.nCells()*8));

    stage2_grid = matrixToMNGrid_rows(m, rows);

    // list of lists

    LL<Int> stage3_cells = matrixOfMatricesToListOfLists(stage2_grid);

    search = jeCompressionSearch(stage3_cells, dataChars);

    strat = new JE_CompressEachElementIndividually<LInt>()

      .elementCompressionStrategy(-> new JE_RepElement)

      .onCompressionFail(ints -> javaObjectToIJavaExpr(ints);

    search.addStrategy(strat);

    ret search;

  }

  S stats() { ret strat?.stats(); }

  JECompressionSearch<LLInt>.Submission winner() {

    ret search?.bestSubmission();

  }

  IJavaExpr<LL<Int>> winnerCodeWithoutPostProcessing() {

    ret winner()?.decompressor();

  }

  IJavaExpr<BufferedImage> winnerCode() {

    var innerWinner = winnerCodeWithoutPostProcessing();

    if (innerWinner == null) null;

    ret addPostProcessing(innerWinner);

  }

  L<Int> cellWidths() { ret lambdaMapMethod getWidth(rowToList(stage2_grid, 0)); }

  L<Int> cellHeights() { ret lambdaMapMethod getHeight(colToList(stage2_grid, 0)); }

  // post processing goes from stage 3 back to stage 0 (see function "forward")

  IJavaExpr<BufferedImage> addPostProcessing(IJavaExpr<LL<Int>> inner) {

    L<Int> cellWidths = cellWidths();

    L<Int> cellHeights = cellHeights();

    ret new AbstractJavaXExpr<BufferedImage> {

      public FunctionCall javaConstruct() {

        ret functionCall gridLOLToImage(toJava(cellWidths), toJava(cellHeights), inner);

      }

      toString { ret str(javaConstruct()); }

      public BufferedImage quickEval() {

        ret gridLOLToImage(cellWidths, cellHeights, inner.quickEval());

      }

    };

  }

  BufferedImage renderCellsLinearly() {

    ret mergeBufferedImagesHorizontally(

      map intMatrixToImage(matrixToList(stage2_grid)));

  }

  void drawOverlay(ImageSurface is, Graphics2D g) pcall {

    double zoom = is.getZoomX();

    L<Int> cellWidths = cellWidths();

    L<Int> cellHeights = cellHeights();

    L<Int> cellX1s = partialSums_firstIs0(cellWidths);

    L<Int> cellY1s = partialSums_firstIs0(cellHeights);

    for y over cellHeights:

      for x over cellWidths:

        if (strat.isElementCompressed(y*l(cellWidths)+x)) {

          Rect r = rectFromPoints(

            cellX1s.get(x), cellY1s.get(y),

            cellX1s.get(x+1), cellY1s.get(y+1));

          r = scaleRect(r, zoom);

          fillRect(g, r, colorWithAlpha(Color.GREEN, .5));

        }

  }

}