anchor.diff:  }
   
   
  +/**
  + * A fixed-length, random-access sequence of bytes that also provides random
  + * and unaligned access to the fixed-width integers and floating point
  + * numbers represented by those bytes.
  + * ByteData may be used to pack and unpack data from external sources
  + * (such as networks or files systems), and to process large quantities
  + * of numerical data more efficiently than would be possible
  + * with ordinary [List] implementations. ByteData can save space, by
  + * eliminating the need for object headers, and time, by eliminating the
  + * need for data copies. Finally, ByteData may be used to intentionally
  + * reinterpret the bytes representing one arithmetic type as another.
  + * For example this code fragment determine what 32-bit signed integer
  + * is represented by the bytes of a 32-bit floating point number:
  + *
  + *     var buffer = new Uint8List(8).buffer;
  + *     var bdata = new ByteData.view(buffer);
  + *     bdata.setFloat32(0, 3.04);
  + *     int huh = bdata.getInt32(0);
  + */
   class ByteData extends TypedData native "DataView" {
  +  /**
  +   * Creates a [ByteData] of the specified length (in elements), all of
  +   * whose elements are initially zero.
  +   */
     factory ByteData(int length) => _create1(length);
   
  +  /**
  +   * Creates an [ByteData] _view_ of the specified region in the specified
  +   * byte buffer. Changes in the [ByteData] will be visible in the byte
  +   * buffer and vice versa. If the [offsetInBytes] index of the region is not
  +   * specified, it defaults to zero (the first byte in the byte buffer).
  +   * If the length is not specified, it defaults to null, which indicates
  +   * that the view extends to the end of the byte buffer.
  +   *
  +   * Throws [RangeError] if [offsetInBytes] or [length] are negative, or
  +   * if [offsetInBytes] + ([length] * elementSizeInBytes) is greater than
  +   * the length of [buffer].
  +   */
     factory ByteData.view(ByteBuffer buffer,
                           [int byteOffset = 0, int byteLength]) =>
         byteLength == null
             ? _create2(buffer, byteOffset)
             : _create3(buffer, byteOffset, byteLength);
   
  +  /**
  +   * Returns the floating point number represented by the four bytes at
  +   * the specified [byteOffset] in this object, in IEEE 754
  +   * single-precision binary floating-point format (binary32).
  +   *
  +   * Throws [RangeError] if [byteOffset] is negative, or
  +   * `byteOffset + 4` is greater than the length of this object.
  +   */
     num getFloat32(int byteOffset, [Endianness endian=Endianness.BIG_ENDIAN]) =>
         _getFloat32(byteOffset, endian._littleEndian);
   
  
positive.code: }
  
  
  class Int32x4 {
    final _storage = new Int32List(4);
  
  
negative.code:   @Returns('int')
    int _getInt32(int byteOffset, [bool littleEndian]) native;
  
    /**
     * Returns the (possibly negative) integer represented by the eight bytes at
     * the specified [byteOffset] in this object, in two's complement binary
     * form.
     * The return value will be between 2<sup>63</sup> and 2<sup>63</sup> - 1,
     * inclusive.
     *
     * Throws [RangeError] if [byteOffset] is negative, or
     * `byteOffset + 8` is greater than the length of this object.
     */
    int getInt64(int byteOffset, [Endianness endian=Endianness.BIG_ENDIAN]) {
      throw new UnsupportedError("Int64 accessor not supported by dart2js.");
    }
  
    /**
     * Returns the (possibly negative) integer represented by the byte at the
     * specified [byteOffset] in this object, in two's complement binary
     * representation. The return value will be between -128 and 127, inclusive.
     *
     * Throws [RangeError] if [byteOffset] is negative, or
     * greater than or equal to the length of this object.
     */
    int getInt8(int byteOffset) native;
  
    /**
     * Returns the positive integer represented by the two bytes starting
     * at the specified [byteOffset] in this object, in unsigned binary
     * form.
     * The return value will be between 0 and  2<sup>16</sup> - 1, inclusive.
     *
     * Throws [RangeError] if [byteOffset] is negative, or
     * `byteOffset + 2` is greater than the length of this object.
     */
    int getUint16(int byteOffset, [Endianness endian=Endianness.BIG_ENDIAN]) =>
        _getUint16(byteOffset, endian._littleEndian);
  
  