anchor.diff:  
     @override
     Future<bool> loadAtlases(List<Uint8List> rawAtlases) async {
  -    List<ui.Codec> codecs =  await Future.wait(rawAtlases.map((Uint8List buffer) => ui.instantiateImageCodec(buffer)));
  -    List<ui.FrameInfo> frames = await Future.wait(codecs.map((ui.Codec codec) => codec.getNextFrame()));
  -    _images = frames.map((ui.FrameInfo frame) => frame.image).toList(growable: false);
  -    print("GOT IMAGES $_images");
  +    List<ui.Codec> codecs = await Future.wait(
  +        rawAtlases.map((Uint8List buffer) => ui.instantiateImageCodec(buffer)));
  +    List<ui.FrameInfo> frames =
  +        await Future.wait(codecs.map((ui.Codec codec) => codec.getNextFrame()));
  +    _images =
  +        frames.map((ui.FrameInfo frame) => frame.image).toList(growable: false);
       return true;
     }
   
     @override
  -  Future<Uint8List> readOutOfBandAsset(String assetFilename, dynamic context) async {
  +  Future<Uint8List> readOutOfBandAsset(
  +      String assetFilename, dynamic context) async {
       _AssetBundleContext bundleContext = context;
       int pathIdx = bundleContext.filename.lastIndexOf('/') + 1;
       String basePath = bundleContext.filename.substring(0, pathIdx);
  
positive.code: 
  import 'dart:ui' as ui;
  import 'dart:math';
  import 'package:flutter/services.dart';
  import 'dart:async';
  import 'dart:typed_data';
  
negative.code:     return _path;
    }
  }
  
  class FlutterActorImage extends ActorImage implements FlutterActorDrawable {
    Float32List _vertexBuffer;
    Float32List _uvBuffer;
    ui.Paint _paint;
    ui.Vertices _canvasVertices;
    Int32List _indices;
  
    final Float64List _identityMatrix = Float64List.fromList(<double>[
      1.0,
      0.0,
      0.0,
      0.0,
      0.0,
      1.0,
      0.0,
      0.0,
      0.0,
      0.0,
      1.0,
      0.0,
      0.0,
      0.0,
      0.0,
      1.0
    ]);
  
    set textureIndex(int value) {
      if (this.textureIndex != value) {
        _paint = ui.Paint()
          ..shader = ui.ImageShader(
              (artboard.actor as FlutterActor).images[textureIndex],
              ui.TileMode.clamp,
              ui.TileMode.clamp,
              _identityMatrix);
        _paint.filterQuality = ui.FilterQuality.low;
        _paint.isAntiAlias = true;
      }
    }
  
    void dispose() {
      _uvBuffer = null;
      _vertexBuffer = null;
      _indices = null;
      _paint = null;
    }
  
    void initializeGraphics() {
      super.initializeGraphics();
      if (triangles == null) {
        return;
      }
      _vertexBuffer = makeVertexPositionBuffer();
      _uvBuffer = makeVertexUVBuffer();
      _indices =
          Int32List.fromList(triangles); // nima runtime loads 16 bit indices
      updateVertexUVBuffer(_uvBuffer);
      int count = vertexCount;
      int idx = 0;
      ui.Image image = (artboard.actor as FlutterActor).images[textureIndex];
  
      // SKIA requires texture coordinates in full image space, not traditional normalized uv coordinates.
      for (int i = 0; i < count; i++) {
        _uvBuffer[idx] = _uvBuffer[idx] * image.width;
        _uvBuffer[idx + 1] = _uvBuffer[idx + 1] * image.height;
        idx += 2;
      }
  
      if (this.sequenceUVs != null) {
        for (int i = 0; i < this.sequenceUVs.length; i++) {
          this.sequenceUVs[i++] *= image.width;
          this.sequenceUVs[i] *= image.height;
        }
      }
  
      _paint = ui.Paint()
        ..shader = ui.ImageShader(
            (artboard.actor as FlutterActor).images[textureIndex],
            ui.TileMode.clamp,
            ui.TileMode.clamp,
            _identityMatrix);
      _paint.filterQuality = ui.FilterQuality.low;
      _paint.isAntiAlias = true;
    }
  
    void invalidateDrawable() {
      _canvasVertices = null;
    }
  
    bool updateVertices() {
      if (triangles == null) {
        return false;
      }
      updateVertexPositionBuffer(_vertexBuffer, false);
  
      //Float32List test = new Float32List.fromList([64.0, 32.0, 0.0, 224.0, 128.0, 224.0]);
      //Int32List colorTest = new Int32List.fromList([const ui.Color.fromARGB(255, 0, 255, 0).value, const ui.Color.fromARGB(255, 0, 255, 0).value, const ui.Color.fromARGB(255, 0, 255, 0).value]);
      //_canvasVertices = new ui.Vertices.raw(ui.VertexMode.triangles, test, colors:colorTest /*textureCoordinates: _uvBuffer, indices: _indices*/);
      // int uvOffset;
  
      // if (this.sequenceUVs != null) {
      //   int framesCount = this.sequenceFrames.length;
      //   int currentFrame = this.sequenceFrame % framesCount;
  
      //   SequenceFrame sf = this.sequenceFrames[currentFrame];
      //   uvOffset = sf.offset;
      //   textureIndex = sf.atlasIndex;
  
      //   int uvStride = 8;
      //   int uvRow = currentFrame * uvStride;
      //   Iterable<double> it = this.sequenceUVs.getRange(uvRow, uvRow + uvStride);
      //   List<double> uvList = List.from(it);
      //   _uvBuffer = Float32List.fromList(uvList);
      // }
      _canvasVertices = ui.Vertices.raw(ui.VertexMode.triangles, _vertexBuffer,
          indices: _indices, textureCoordinates: _uvBuffer);
      return true;
    }
  
    draw(ui.Canvas canvas) {
      if (triangles == null || renderCollapsed || renderOpacity <= 0) {
        return;
      }
  
      if (_canvasVertices == null && updateVertices()) {
        return;
      }
      _paint.color = _paint.color.withOpacity(renderOpacity);
      //_paint.isAntiAlias = true;
      canvas.drawVertices(_canvasVertices, ui.BlendMode.srcOver, _paint);
    }
  
    @override
    ActorComponent makeInstance(ActorArtboard resetArtboard) {
      FlutterActorImage instanceNode = FlutterActorImage();
      instanceNode.copyImage(this, resetArtboard);
      return instanceNode;
    }
  
    AABB computeAABB() {
      this.updateVertices();
  
      double minX = double.infinity;
      double minY = double.infinity;
      double maxX = double.negativeInfinity;
      double maxY = double.negativeInfinity;
  
      int readIdx = 0;
      if (_vertexBuffer != null) {
        int nv = _vertexBuffer.length ~/ 2;
  
        for (int i = 0; i < nv; i++) {
          double x = _vertexBuffer[readIdx++];
          double y = _vertexBuffer[readIdx++];
          if (x < minX) {
            minX = x;
          }
          if (y < minY) {
            minY = y;
          }
          if (x > maxX) {
            maxX = x;
          }
          if (y > maxY) {
            maxY = y;
          }
        }
      }
  
      return AABB.fromValues(minX, minY, maxX, maxY);
    }
  }
  