anchor.diff:        static; inline;
   
       class function ReadPUInt64AsUInt64LE(AInput: PUInt64): UInt64;
  +      static; inline;
  +
  +    class function ReadPCardinalAsUInt32BE(AInput: PCardinal): UInt32;
  +      static; inline;
  +
  +    class function ReadPUInt64AsUInt64BE(AInput: PUInt64): UInt64;
         static; inline;
   
       class function ReadBytesAsUInt32LE(AInput: PByte; AIndex: Int32): UInt32;
  
positive.code:   AOutput[AIndex + 5] := Byte(AInput shr 40);
    AOutput[AIndex + 6] := Byte(AInput shr 48);
    AOutput[AIndex + 7] := Byte(AInput shr 56);
  end;
  
  class procedure TConverters.ReadUInt64AsBytesBE(AInput: UInt64;
    const AOutput: THashLibByteArray; AIndex: Int32);
  begin
    AOutput[AIndex] := Byte(AInput shr 56);
    AOutput[AIndex + 1] := Byte(AInput shr 48);
    AOutput[AIndex + 2] := Byte(AInput shr 40);
  
negative.code: class function TConverters.ReadPCardinalAsUInt32LE(AInput: PCardinal): UInt32;
  begin
    result := le2me_32(ReadPCardinalAsUInt32(AInput));
  end;
  
  class function TConverters.ReadPUInt64AsUInt64LE(AInput: PUInt64): UInt64;
  begin
    result := le2me_64(ReadPUInt64AsUInt64(AInput));
  end;
  
  class function TConverters.ReadPCardinalAsUInt32BE(AInput: PCardinal): UInt32;
  begin
    result := be2me_32(ReadPCardinalAsUInt32(AInput));
  end;
  
  class function TConverters.ReadPUInt64AsUInt64BE(AInput: PUInt64): UInt64;
  begin
    result := be2me_64(ReadPUInt64AsUInt64(AInput));
  end;
  
  class function TConverters.ReadBytesAsUInt32LE(AInput: PByte;
    AIndex: Int32): UInt32;
  begin
    result := ReadPCardinalAsUInt32LE(PCardinal(AInput + AIndex));
    // while this below is slower, it's portable
    // result := (UInt32(AInput[AIndex])) or (UInt32(AInput[AIndex + 1]) shl 8) or
    // (UInt32(AInput[AIndex + 2]) shl 16) or (UInt32(AInput[AIndex + 3]) shl 24);
  end;
  
  class function TConverters.ReadBytesAsUInt64LE(AInput: PByte;
    AIndex: Int32): UInt64;
  begin
    result := ReadPUInt64AsUInt64LE(PUInt64(AInput + AIndex));
    // while this below is slower, it's portable
    // result := (UInt64(AInput[AIndex])) or (UInt64(AInput[AIndex + 1]) shl 8) or
    // (UInt64(AInput[AIndex + 2]) shl 16) or (UInt64(AInput[AIndex + 3]) shl 24)
  