W lengthInBytes asUint8List asInt8ListasUint8ClampedList asUint16List asInt16List asUint32List asInt32List asUint64List asInt64List asInt32x4List asFloat32List asFloat64ListasFloat32x4ListasFloat64x2List asByteDataelementSizeInBytes offsetInBytesbuffer+ _littleEndianbiglittlehostasUnmodifiableViewgetInt8setInt8getUint8setUint8getInt16setInt16 getUint16 setUint16getInt32setInt32 getUint32 setUint32getInt64setInt64 getUint64 setUint64 getFloat32 setFloat32 getFloat64 setFloat64sublistbytesPerElement-*/lessThanlessThanOrEqual greaterThangreaterThanOrEqualequalnotEqualscaleabsclampxyzwsignMaskxxxxxxxyxxxzxxxwxxyxxxyyxxyzxxywxxzxxxzyxxzzxxzwxxwxxxwyxxwzxxwwxyxxxyxyxyxzxyxwxyyxxyyyxyyzxyywxyzxxyzyxyzzxyzwxywxxywyxywzxywwxzxxxzxyxzxzxzxwxzyxxzyyxzyzxzywxzzxxzzyxzzzxzzwxzwxxzwyxzwzxzwwxwxxxwxyxwxzxwxwxwyxxwyyxwyzxwywxwzxxwzyxwzzxwzwxwwxxwwyxwwzxwwwyxxxyxxyyxxzyxxwyxyxyxyyyxyzyxywyxzxyxzyyxzzyxzwyxwxyxwyyxwzyxwwyyxxyyxyyyxzyyxwyyyxyyyyyyyzyyywyyzxyyzyyyzzyyzwyywxyywyyywzyywwyzxxyzxyyzxzyzxwyzyxyzyyyzyzyzywyzzxyzzyyzzzyzzwyzwxyzwyyzwzyzwwywxxywxyywxzywxwywyxywyyywyzywywywzxywzyywzzywzwywwxywwyywwzywwwzxxxzxxyzxxzzxxwzxyxzxyyzxyzzxywzxzxzxzyzxzzzxzwzxwxzxwyzxwzzxwwzyxxzyxyzyxzzyxwzyyxzyyyzyyzzyywzyzxzyzyzyzzzyzwzywxzywyzywzzywwzzxxzzxyzzxzzzxwzzyxzzyyzzyzzzywzzzxzzzyzzzzzzzwzzwxzzwyzzwzzzwwzwxxzwxyzwxzzwxwzwyxzwyyzwyzzwywzwzxzwzyzwzzzwzwzwwxzwwyzwwzzwwwwxxxwxxywxxzwxxwwxyxwxyywxyzwxywwxzxwxzywxzzwxzwwxwxwxwywxwzwxwwwyxxwyxywyxzwyxwwyyxwyyywyyzwyywwyzxwyzywyzzwyzwwywxwywywywzwywwwzxxwzxywzxzwzxwwzyxwzyywzyzwzywwzzxwzzywzzzwzzwwzwxwzwywzwzwzwwwwxxwwxywwxzwwxwwwyxwwyywwyzwwywwwzxwwzywwzzwwzwwwwxwwwywwwzwwwwshuffle shuffleMixwithXwithYwithZwithWminmaxsqrt reciprocalreciprocalSqrt|&^flagXflagYflagZflagW withFlagX withFlagY withFlagZ withFlagWselect ByteBuffer TypedData TypedDataList _TypedIntList_TypedFloatListEndianByteDataInt8List Uint8ListUint8ClampedList Int16List Uint16List Int32List Uint32List Int64List Uint64List Float32List Float64List Float32x4List Int32x4List Float64x2List Float32x4Int32x4 Float64x2/dart typed_dataSinceUnmodifiableListBase BytesBuilderint offsetInByteslengthhostListbufferdoublebool_viewfromListgetInt8pragma sublistView asByteDatastartendelementSizeInBytes RangeErrorcheckValidRange lengthInBytesvoidbig asInt8List asUint8ListasUint8ClampedList asInt16List ArgumentError asUint16List asInt32List asUint32List asInt64List asUint64List asFloat32List asFloat64ListasFloat32x4List asInt32x4ListasFloat64x2Listxyzw TypedDataList TypedDataList _TypedIntList_TypedFloatListY[iWLiF^o BytesBuilderFdart:_internal#CSinceUnmodifiableListBase dart:_internalfyN؀ف PTz EFqri{̓+1lɄυgmc'm׈!'sy҉Z[5KQ;Ao23x~mՎ>ߎ(ZԐZ`NntՒۓ ;f:@{Ôٔߕ/`PciʖЖ1\17rϘՙ%VיFY_ƚ'R&,gŜ˝L͝=PVJڟ۠%`áD{š5HNBУѤX< YntاSݧg}өJi̩Ҫ39gūWX߬(>D *{)]ׯci \԰ATZ±&Q17rӳٴ*X"(uo;5;1npqkӺ/0c|~ĻҼ]޽*J9?̿L{}~@;@@@AAZA^AAB9B}BBBBC C3C4CaCCCDDDDDaDDDEEgEEFFQFUFFFFG GXGbGhGpGtGGH8HzHHHHIIIIkI{IIJJ;JdJeJJJK KOKKKKL0LfLLLM#M]MMMN/N9NiNNNNOO[OOOOOOPP"P#PePkPPQ7Q~QQQRR4R:RRRS SWSSSSSSTTGTjTqTuTvTTTTUU`UvU|UUUVV=V>VVVVWAWGWxWWWXXOXUXXXXYYY]YYYZ ZZDZoZZZ[.[:[@[[[[\'\e\f\\]&],]S]]]^^e^f^^^__M_S__```c```aa+a1abaaabEbbbbcc c:cccdd^ddddde0eeef fTf`fffffg:gygzghh4h:hhhhhiieifiijj j[jljrjjk1k2k|kkkl#ldljllm5m6mymmmnn%nVnnno7o}oooppp8pppqqRqqqrr\r]rrs$s*sssttNttu4ujupuuv@vAvvwww7wwwxxYxxxyyiykylyyyz)z-ztzzz{+{;{t{{{|=|f|g|||}}N}T}}}}~6~<~x~~<rx,2}?/=jt#<Up Pbh ]c&LYd AQrsb@JP+V&*f<PT6_e(LR -hiT5>x LV:z ?CD Y"V\-z;k17BC2Z`n"gm{(m9 :>5^d,hn7D9O,2s7|DRDN7RcjA{SYNT Agt -489l|CF$.4uACD(,p,=w1Oyz0bh TZ6[$KQ*d8Bs&f+/0tzF CI k%2=fmŸ&FOUyé89ąċ QWeŞ ^drƣƭƳdǐǑǹǻǼWȢȦ+AEɒɤ'SYʙʷ,PV˚9uv̵!7z͹[Χhϭ,o}н .]gѭ1Jev}ҴҸҹHӂZ`ԒԘU[գթ Z։ּ֯)Vqװ4Y`deؒآ]٭,Zژڢڨ2<Bۃۮ !IKLܔܥܩ04x=NވB`ߊߋAsyekGl5\b;u IS7w<@A W TZ+1|7DOx8Xag(JK2ciw%+pv1v)-i=X\>jpCgm)P8N+1r.4C7Et~-Ha|_-qw/lr $rAnLqx|}*0u Dr JTZ 89acdHLhy'-m " ( l     F G     3 r     `     ! f  '5t~b*1gkl5 EKV\=cp{ %d DTvw^ GQW2]DUY(i,t/0y_$*o  , b h  !!"!e!k!!"5"z""# ##G#n#|###$;$d$$$$$%%%%K%Q%%&&d&&&&'' 'f''''(B(\((() ))@)G)y))** *)*/*T*******+++b+h++,.,4,B,|,,,,-=-C-Q-----.C.p.q....///3/~///0-0L0P0001:1c1i11112>2b2h2223$3K33334484{44555\555666i667.7q77778$828b8l889979P9k9|9999:: :Q::;;c;i;;;;>4>a>|>>>>??@?e?l?p?q????@ @&@l@@@AAFAxAAAB BB BYBcBiBBCCHCICqCsCtCCCD DWD~DDDE ElEEEEF%F&FpFFFGGAGBGGGGH1HpHHHII^IIIIJJdJJK'K5KvKKKKLL"LhLLLMM!M2M9MqMuMvMMNN@NNOOOPOVOOOPPPaPgPPQQJQpQ}QQQQRR2RqRRRRRSS"S&S'SUSeSSSST"TrTTTTU.UmUwU}UUUVVVV`VVVVW'W)W*WoWWWX XX]XrXXYYAYGYYYYZ!ZEZKZZZZ[E[K[[[\+\P\\\]]@]F]]]^^Y^^^_5_?_t____`+`k``````a8a<a=aaab bVbbbcccScYcccd*d0d{ddee=eJeUe~eeeef>f^fgfmffffffg&g6g\g]gggh)h^h_hhhiIiziiiiijj7jVj`jjjjk5k;kIkkkkllFlvlwllllllm=mmnnHnNnnnno$oHoNoooopBpHpppq&qKqqqrr;rArrrssTssst,t6tittttuu^uuuuuuv'v+v,vrvxvvwDwwwxx xAxGxxxyyyiyyzz)z6zAzjzqzzz{*{J{S{Y{{{{{{|||B|C|u|{|} }:};}}}~$~U~[~i~~~~%/lcms$RS|~aef12~UV"WXK,x9~CQ:D*EV]/iAGy<BHwD_%JQUV W2Kd}+5;,W $g6ouK)]DA-3EK%+v<BL>gh &,^P6qw9r0g9ioH?vT d[g28|+s>*+NTG J)*QWJ Q34_e(o$*y7syD N4ag"23Tde Ba%Oop‹‘»'GHciÓóô ;AkċČħĭCcdŅů;<W]ƇƧƨ/5_ǀǛǡ 7WXsyȣ/0KQ{ɛɜɷɽ#)Sstʏʕʿ+KLgm˗˷˸#$?Eȍ̫̱̐Ggh͉̓ͳ?@[a΋Ϋά39cστϟϥ ;[\w}Ч34OUџѠѻ  '-Wwxғҙ/OPkqӛӻӼ'(CIsԓԔԯԵ!KklՇՍշ#CD_e֏ְ֯7=gׇ׈ףש?_`{؁ث78SYك٣٤ٿ+1[{|ڗڝ 3STou۟ۿ +,GMwܗܘܹܳ%Oop݋ݑݻ'GHciޓ޳޴ ;Akߋߌߧ߭Ccd;<W]/5_ 7WXsy/0KQ{#)Sst+KLgm#$?EoGgh?@[a39c ;[\w}34OU  '-Wwx/OPkq'(CIs!Kkl#CD_e7=g?_`{78SY+1[{| 3STou +,GMw%Oop'GHci ;AkCcd;<W]/5_ 7WXsy/0KQ{#)Sst+KLgm#$?EoGgh?@[a39c ;[\w}34OU  '-Wwx  / O P k q       ' ( C I s         ! K k l        # C D _ e         7 = g       ?_`{78SY+1[{| 3STou +,GMw%Oop'GHci ;AkCcd;<W]/5_ 7WXsy/0KQ{#)Sst+KLgm#$?EoGgh?@[a   3 9 c       ! !!;![!\!w!}!!!!!""3"4"O"U""""""# # #'#-#W#w#x######$$/$O$P$k$q$$$$$%%'%(%C%I%s%%%%%%&&&!&K&k&l&&&&&&&'#'C'D'_'e''''''(((7(=(g((((((()))?)_)`){))))))**7*8*S*Y******+++++1+[+{+|+++++,, ,3,S,T,o,u,,,,,- -+-,-G-M-w-----...7.=...//_///0B001!161<1111292?2|222333M3344$4i44455W55556"6c666777`77888R8X889'9D9E999::e::::::;@;;;<4<]>b>>>>>>>?H?\?b??@@V@@@AAAA1A7AAAB BTBBBC C'C(CaCgCCD#DfDDDE?EfEEEF=F[F]F^FzF~FFGG>GGGGHHH"HGHHHiHHHHHHIII7IDIEIlIyIzIIIIIIJ.JGJ`JyJJJJJKK7KWKwKKKKLL7LWLwLLLLMM7MWMwMMMMNN7NWNwNNNNOO7OWOwOOOOPP7PWPwPPPPQQ7QWQwQQQQRR7RWRwRRRRSS7SWSwSSSSTT7TWTwTTTTUU7UWUwUUUUVV7VWVwVVVVWW7WWWwWWWWXX7XWXwXXXXYY7YWYwYYYYZZ7ZWZwZZZZ[[7[W[w[[[[\\7\W\w\\\\]]7]W]w]]]]^^7^W^w^^^^__7_W_w____``7`W`w````aa7aWawaaaabb7bWbwbbbbcc7cWcwccccdd7dWdwddddee7eWeweeeeff7fWfwffffgg7gWgwgggghh7hWhwhhhhii7iWiwiiiijj7jWjwjjjjk(kEkFkkl l8l9llllmmmRmjmkmmmnn+n,ntnnnnno*o<o=ooooppp`p}p~pppq4qxqqqrr3r7rwrrrss&sXssssttt*tStTtkttttttuuu.uWuXuuuuv(v;v<vvvvvvwwww*w+wwwwwwxxx2x3x}xxxxy y yOyqyryyy/// Lists that efficiently handle fixed sized data /// (for example, unsigned 8 byte integers) and SIMD numeric types. /// /// To use this library in your code: /// ```dart /// import 'dart:typed_data'; /// ``` /// {@category Core} /// {@canonicalFor dart:_internal.BytesBuilder} #CF^or/// A sequence of bytes underlying a typed data object. /// /// Used to process large quantities of binary or numerical data /// more efficiently using a typed view. /// /// It is a compile-time error for a class to attempt to extend or implement /// `ByteBuffer`.F-/// The length of this byte buffer, in bytes.邸oo_/// Creates a [Uint8List] _view_ of a region of this byte buffer. /// /// The view is backed by the bytes of this byte buffer. /// Any changes made to the `Uint8List` will also change the buffer, /// and vice versa. /// /// The viewed region start at [offsetInBytes] and contains [length] bytes. /// If [length] is omitted, the range extends to the end of the buffer. /// /// The start index and length must describe a valid range of the buffer: /// /// * `offsetInBytes` must not be negative, /// * `length` must not be negative, and /// * `offsetInBytes + length` must not be greater than [lengthInBytes].| ((]/// Creates a [Int8List] _view_ of a region of this byte buffer. /// /// The view is backed by the bytes of this byte buffer. /// Any changes made to the `Int8List` will also change the buffer, /// and vice versa. /// /// The viewed region start at [offsetInBytes] and contains [length] bytes. /// If [length] is omitted, the range extends to the end of the buffer. /// /// The start index and length must describe a valid range of the buffer: /// /// * `offsetInBytes` must not be negative, /// * `length` must not be negative, and /// * `offsetInBytes + length` must not be greater than [lengthInBytes].498K QPH]ԋm/// Creates a [Uint8ClampedList] _view_ of a region of this byte buffer. /// /// The view is backed by the bytes of this byte buffer. /// Any changes made to the `Uint8ClampedList` will also change the buffer, /// and vice versa. /// /// The viewed region start at [offsetInBytes] and contains [length] bytes. /// If [length] is omitted, the range extends to the end of the buffer. /// /// The start index and length must describe a valid range of the buffer: /// /// * `offsetInBytes` must not be negative, /// * `length` must not be negative, and /// * `offsetInBytes + length` must not be greater than [lengthInBytes]. # )( 5ߏx/// Creates a [Uint16List] _view_ of a region of this byte buffer. /// /// The view is backed by the bytes of this byte buffer. /// Any changes made to the `Uint16List` will also change the buffer, /// and vice versa. /// /// The viewed region start at [offsetInBytes], which must be 16-bit aligned, /// and contains [length] 16-bit integers with /// the same endianness as the host ([Endian.host]). /// If [length] is omitted, the range extends as far towards the end of /// the buffer as possible - /// if [lengthInBytes] is not even, the last byte can't be part of the view. /// /// The start index and length must describe a valid 16-bit aligned range /// of the buffer: /// /// * `offsetInBytes` must not be negative, /// * `offsetInBytes` must be divisible by two, /// * `length` must not be negative, and /// * `offsetInBytes + length * 2` must not be greater than [lengthInBytes].  ۓv/// Creates a [Int16List] _view_ of a region of this byte buffer. /// /// The view is backed by the bytes of this byte buffer. /// Any changes made to the `Int16List` will also change the buffer, /// and vice versa. /// /// The viewed region start at [offsetInBytes], which must be 16-bit aligned, /// and contains [length] 16-bit integers with /// the same endianness as the host ([Endian.host]). /// If [length] is omitted, the range extends as far towards the end of /// the buffer as possible - /// if [lengthInBytes] is not even, the last byte can't be part of the view. /// /// The start index and length must describe a valid 16-bit aligned range /// of the buffer: /// /// * `offsetInBytes` must not be negative, /// * `offsetInBytes` must be divisible by two, /// * `length` must not be negative, and /// * `offsetInBytes + length * 2` must not be greater than [lengthInBytes]. /// Creates a [Uint32List] _view_ of a region of this byte buffer. /// /// The view is backed by the bytes of this byte buffer. /// Any changes made to the `Uint32List` will also change the buffer, /// and vice versa. /// /// The viewed region start at [offsetInBytes], which must be 32-bit aligned, /// and contains [length] 32-bit integers with /// the same endianness as the host ([Endian.host]). /// If [length] is omitted, the range extends as far towards the end of /// the buffer as possible - /// if [lengthInBytes] is not divisible by four, the last bytes can't be part /// of the view. /// /// The start index and length must describe a valid 32-bit aligned range /// of the buffer: /// /// * `offsetInBytes` must not be negative, /// * `offsetInBytes` must be divisible by four, /// * `length` must not be negative, and /// * `offsetInBytes + length * 4` must not be greater than [lengthInBytes]. ڗ/// Creates a [Int32List] _view_ of a region of this byte buffer. /// /// The view is backed by the bytes of this byte buffer. /// Any changes made to the `Int32List` will also change the buffer, /// and vice versa. /// /// The viewed region start at [offsetInBytes], which must be 32-bit aligned, /// and contains [length] 32-bit integers with /// the same endianness as the host ([Endian.host]). /// If [length] is omitted, the range extends as far towards the end of /// the buffer as possible - /// if [lengthInBytes] is not divisible by four, the last bytes can't be part /// of the view. /// /// The start index and length must describe a valid 32-bit aligned range /// of the buffer: /// /// * `offsetInBytes` must not be negative, /// * `offsetInBytes` must be divisible by four, /// * `length` must not be negative, and /// * `offsetInBytes + length * 4` must not be greater than [lengthInBytes]. Λ/// Creates a [Uint64List] _view_ of a region of this byte buffer. /// /// The view is backed by the bytes of this byte buffer. /// Any changes made to the `Uint64List` will also change the buffer, /// and vice versa. /// /// The viewed region start at [offsetInBytes], which must be 64-bit aligned, /// and contains [length] 64-bit integers with /// the same endianness as the host ([Endian.host]). /// If [length] is omitted, the range extends as far towards the end of /// the buffer as possible - /// if [lengthInBytes] is not divisible by eight, the last bytes can't be part /// of the view. /// /// The start index and length must describe a valid 64-bit aligned range /// of the buffer: /// /// * `offsetInBytes` must not be negative, /// * `offsetInBytes` must be divisible by eight, /// * `length` must not be negative, and /// * `offsetInBytes + length * 8` must not be greater than [lengthInBytes]. ȟ݃/// Creates a [Int64List] _view_ of a region of this byte buffer. /// /// The view is backed by the bytes of this byte buffer. /// Any changes made to the `Int64List` will also change the buffer, /// and vice versa. /// /// The viewed region start at [offsetInBytes], which must be 64-bit aligned, /// and contains [length] 64-bit integers with /// the same endianness as the host ([Endian.host]). /// If [length] is omitted, the range extends as far towards the end of /// the buffer as possible - /// if [lengthInBytes] is not divisible by eight, the last bytes can't be part /// of the view. /// /// The start index and length must describe a valid 64-bit aligned range /// of the buffer: /// /// * `offsetInBytes` must not be negative, /// * `offsetInBytes` must be divisible by eight, /// * `length` must not be negative, and /// * `offsetInBytes + length * 8` must not be greater than [lengthInBytes]. Ӄ§aaY/// Creates a [Int32x4List] _view_ of a region of this byte buffer. /// /// The view is backed by the bytes of this byte buffer. /// Any changes made to the `Int32x4List` will also change the buffer, /// and vice versa. /// /// The viewed region start at [offsetInBytes], which must be 128-bit aligned, /// and contains [length] 128-bit integers. /// If [length] is omitted, the range extends as far towards the end of /// the buffer as possible - /// if [lengthInBytes] is not divisible by 16, the last bytes can't be part /// of the view. /// /// The start index and length must describe a valid 128-bit aligned range /// of the buffer: /// /// * `offsetInBytes` must not be negative, /// * `offsetInBytes` must be divisible by sixteen, /// * `length` must not be negative, and /// * `offsetInBytes + length * 16` must not be greater than [lengthInBytes].put ""T/// Creates a [Float32List] _view_ of a region of this byte buffer. /// /// The view is backed by the bytes of this byte buffer. /// Any changes made to the `Float32List` will also change the buffer, /// and vice versa. /// /// The viewed region start at [offsetInBytes], which must be 32-bit aligned, /// and contains [length] 32-bit integers. /// If [length] is omitted, the range extends as far towards the end of /// the buffer as possible - /// if [lengthInBytes] is not divisible by four, the last bytes can't be part /// of the view. /// /// The start index and length must describe a valid 32-bit aligned range /// of the buffer: /// /// * `offsetInBytes` must not be negative, /// * `offsetInBytes` must be divisible by four, /// * `length` must not be negative, and /// * `offsetInBytes + length * 4` must not be greater than [lengthInBytes].165H NMEZV/// Creates a [Float64List] _view_ of a region of this byte buffer. /// /// The view is backed by the bytes of this byte buffer. /// Any changes made to the `Float64List` will also change the buffer, /// and vice versa. /// /// The viewed region start at [offsetInBytes], which must be 64-bit aligned, /// and contains [length] 64-bit integers. /// If [length] is omitted, the range extends as far towards the end of /// the buffer as possible - /// if [lengthInBytes] is not divisible by eight, the last bytes can't be part /// of the view. /// /// The start index and length must describe a valid 64-bit aligned range /// of the buffer: /// /// * `offsetInBytes` must not be negative, /// * `offsetInBytes` must be divisible by eight, /// * `length` must not be negative, and /// * `offsetInBytes + length * 8` must not be greater than [lengthInBytes]. ʲ]/// Creates a [Float32x4List] _view_ of a region of this byte buffer. /// /// The view is backed by the bytes of this byte buffer. /// Any changes made to the `Float32x4List` will also change the buffer, /// and vice versa. /// /// The viewed region start at [offsetInBytes], which must be 128-bit aligned, /// and contains [length] 128-bit integers. /// If [length] is omitted, the range extends as far towards the end of /// the buffer as possible - /// if [lengthInBytes] is not divisible by 16, the last bytes can't be part /// of the view. /// /// The start index and length must describe a valid 128-bit aligned range /// of the buffer: /// /// * `offsetInBytes` must not be negative, /// * `offsetInBytes` must be divisible by sixteen, /// * `length` must not be negative, and /// * `offsetInBytes + length * 16` must not be greater than [lengthInBytes]. ֲʶ]/// Creates a [Float64x2List] _view_ of a region of this byte buffer. /// /// The view is backed by the bytes of this byte buffer. /// Any changes made to the `Float64x2List` will also change the buffer, /// and vice versa. /// /// The viewed region start at [offsetInBytes], which must be 128-bit aligned, /// and contains [length] 128-bit integers. /// If [length] is omitted, the range extends as far towards the end of /// the buffer as possible - /// if [lengthInBytes] is not divisible by 16, the last bytes can't be part /// of the view. /// /// The start index and length must describe a valid 128-bit aligned range /// of the buffer: /// /// * `offsetInBytes` must not be negative, /// * `offsetInBytes` must be divisible by sixteen, /// * `length` must not be negative, and /// * `offsetInBytes + length * 16` must not be greater than [lengthInBytes]. <<]/// Creates a [ByteData] _view_ of a region of this byte buffer. /// /// The view is backed by the bytes of this byte buffer. /// Any changes made to the `ByteData` will also change the buffer, /// and vice versa. /// /// The viewed region start at [offsetInBytes] and contains [length] bytes. /// If [length] is omitted, the range extends to the end of the buffer. /// /// The start index and length must describe a valid range of the buffer: /// /// * `offsetInBytes` must not be negative, /// * `length` must not be negative, and /// * `offsetInBytes + length` must not be greater than [lengthInBytes].HML_ ed\q /// A typed view of a sequence of bytes. /// /// It is a compile-time error for a class to attempt to extend or implement /// `TypedData`.iuuK/// The number of bytes in the representation of each element in this list._F/// The offset of this view into the underlying byte buffer, in bytes.?  &/// The length of this view, in bytes.2Itt0/// The byte buffer associated with this object.D/// A [TypedData] fixed-length [List]-view on the bytes of [buffer].ĻŻʻл˼//_\)/// The concatenation of this list and [other]. /// /// If other is also a typed-data integer list, the returned list will /// be a type-data integer list capable of containing all the elements of /// this list and of [other]. /// Otherwise the returned list will be a normal growable `List`. qdd8/// The concatenation of this list and [other]. /// /// If other is also a typed-data floating point number list, /// the returned list will be a type-data float list capable of containing /// all the elements of this list and of [other]. /// Otherwise the returned list will be a normal growable `List`.fts~BB]/// Endianness of number representation. /// /// The order of bytes in memory of a number representation, with /// [little] endian having the least significant byte first, and [big] endian /// (aka. network byte order) having the most significant byte first. /// /// The [host] endian is the native endianness of the underlying platform, /// and the default endianness used by typed-data lists, like [Uint16List], /// on this platform. Always one of [little] or [big] endian. /// /// Can be specified when accessing or updating a sequence of bytes using a /// [ByteData] view. The host endianness can be used if accessing larger /// numbers by their bytes, for example through a [Uint8List] view on /// a buffer written using an [Int64List] view of the same buffer.. /// /// It is a compile-time error for a class to attempt to extend or implement /// `Endian`.C#CCCCCCC$C#BBBC6)CJCJCPCVCWCXC^CYCc+CwCwCCCCCCC|CCCD CCCCCCCCCCCCCCCCCCCCCCCCCD DWIIg/// 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. /// /// If data comes in as bytes, they can be converted to `ByteData` by /// sharing the same buffer. /// ```dart /// Uint8List bytes = ...; /// var blob = ByteData.sublistView(bytes); /// if (blob.getUint32(0, Endian.little) == 0x04034b50) { // Zip file marker /// ... /// } /// ``` /// /// 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 /// (both stored as big endian): /// ```dart /// var bdata = ByteData(8); /// bdata.setFloat32(0, 3.04); /// int huh = bdata.getInt32(0); // 0x40428f5c /// ``` /// /// It is a compile-time error for a class to attempt to extend or implement /// `ByteData`.IJNJNJVj/// Creates a [ByteData] of the specified length (in elements), all of /// whose bytes are initially zero.JW J\J[J!J"J(J9J)JgOOOOO/// Creates an [ByteData] _view_ of the specified region in [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 provided, /// the view extends to the end of the byte buffer. /// /// The [offsetInBytes] and [length] must be non-negative, and /// [offsetInBytes] + [length] must be less than or /// equal to the length of [buffer]. /// /// Note that when creating a view from a [TypedData] list or byte data, /// that list or byte data may itself be a view on a larger buffer /// with a [TypedData.offsetInBytes] greater than zero. /// Merely doing `ByteData.view(other.buffer, 0, count)` may not /// point to the bytes you intended. Instead you may need to do: /// ```dart /// ByteData.view(other.buffer, other.offsetInBytes, count) /// ``` /// Alternatively, use [ByteData.sublistView] /// which includes this computation: /// ```dart /// ByteData.sublistView(other, 0, count); /// ``` /// (The third argument is an end index rather than a length, so if /// you start from a position greater than zero, you need not /// reduce the count correspondingly).OOOOOOO OOOP%OSSSS)S/// Creates a [ByteData] view on a range of elements of [data]. /// /// Creates a view on the range of `data.buffer` which corresponds /// to the elements of [data] from [start] until [end]. /// If [data] is a typed data list, like [Uint16List], then the view is on /// the bytes of the elements with indices from [start] until [end]. /// If [data] is a [ByteData], it's treated like a list of bytes. /// /// If provided, [start] and [end] must satisfy /// /// 0 ≤ `start` ≤ `end` ≤ *elementCount* /// /// where *elementCount* is the number of elements in [data], which /// is the same as the [List.length] of a typed data list. /// /// If omitted, [start] defaults to zero and [end] to *elementCount*.S*S5S4S; S@S?SJSPSOSGTxYTT(/// A read-only view of this [ByteData].TTTTTTՁgV$V$:/// 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. /// /// The [byteOffset] must be non-negative, and /// less than the length of this object.V,V1V0V@WWT/// Sets the byte at the specified [byteOffset] in this object to the /// two's complement binary representation of the specified [value], which /// must fit in a single byte. /// /// In other words, [value] must be between -128 and 127, inclusive. /// /// The [byteOffset] must be non-negative, and /// less than the length of this object.WWWW WWWсBXX/// The positive integer represented by the byte at the specified /// [byteOffset] in this object, in unsigned binary form. /// /// The return value will be between 0 and 255, inclusive. /// /// The [byteOffset] must be non-negative, and /// less than the length of this object.YYYYZvZvI/// Sets the byte at the specified [byteOffset] in this object to the /// unsigned binary representation of the specified [value], which must fit /// in a single byte. /// /// In other words, [value] must be between 0 and 255, inclusive. /// /// The [byteOffset] must be non-negative, and /// less than the length of this object.ZZZZ ZZZ\-\-x/// The (possibly negative) integer represented by the two bytes at /// the specified [byteOffset] in this object, in two's complement binary /// form. /// /// The return value will be between -215 and 215 - 1, /// inclusive. /// /// The [byteOffset] must be non-negative, and /// `byteOffset + 2` must be less than or equal to the length of this object.\6\;\:\G\O\N\W\]\^\h^"^"/// Sets the two bytes starting at the specified [byteOffset] in this /// object to the two's complement binary representation of the specified /// [value], which must fit in two bytes. /// /// In other words, [value] must lie /// between -215 and 215 - 1, inclusive. /// /// The [byteOffset] must be non-negative, and /// `byteOffset + 2` must be less than or equal to the length of this object.^+^0^/^; ^@^?^G^O^N^W^]^^^h__ځ]/// 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 216 - 1, inclusive. /// /// The [byteOffset] must be non-negative, and /// `byteOffset + 2` must be less than or equal to the length of this object.______`` ` `aa/// Sets the two bytes starting at the specified [byteOffset] in this object /// to the unsigned binary representation of the specified [value], /// which must fit in two bytes. /// /// In other words, [value] must be between /// 0 and 216 - 1, inclusive. /// /// The [byteOffset] must be non-negative, and /// `byteOffset + 2` must be less than or equal to the length of this object.aaaa aaaaaaaabccy/// The (possibly negative) integer represented by the four bytes at /// the specified [byteOffset] in this object, in two's complement binary /// form. /// /// The return value will be between -231 and 231 - 1, /// inclusive. /// /// The [byteOffset] must be non-negative, and /// `byteOffset + 4` must be less than or equal to the length of this object.ccccccccccˁee/// Sets the four bytes starting at the specified [byteOffset] in this /// object to the two's complement binary representation of the specified /// [value], which must fit in four bytes. /// /// In other words, [value] must lie /// between -231 and 231 - 1, inclusive. /// /// The [byteOffset] must be non-negative, and /// `byteOffset + 4` must be less than or equal to the length of this object.eeee eeeeeeeeég@g@^/// The positive integer represented by the four bytes starting /// at the specified [byteOffset] in this object, in unsigned binary /// form. /// /// The return value will be between 0 and 232 - 1, inclusive. /// /// The [byteOffset] must be non-negative, and /// `byteOffset + 4` must be less than or equal to the length of this object.gJgOgNg[gcgbgkgqgrg|i!i!/// Sets the four bytes starting at the specified [byteOffset] in this object /// to the unsigned binary representation of the specified [value], /// which must fit in four bytes. /// /// In other words, [value] must be between /// 0 and 232 - 1, inclusive. /// /// The [byteOffset] must be non-negative, and /// `byteOffset + 4` must be less than or equal to the length of this object.i+i0i/i; i@i?iGiOiNiWi]i^ihjjz/// 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 -263 and 263 - 1, /// inclusive. /// /// The [byteOffset] must be non-negative, and /// `byteOffset + 8` must be less than or equal to the length of this object.kkkkkkk#k)k*k4ll/// Sets the eight bytes starting at the specified [byteOffset] in this /// object to the two's complement binary representation of the specified /// [value], which must fit in eight bytes. /// /// In other words, [value] must lie /// between -263 and 263 - 1, inclusive. /// /// The [byteOffset] must be non-negative, and /// `byteOffset + 8` must be less than or equal to the length of this object.lmlm mmmmmm'm-m.m8nn_/// The positive integer represented by the eight bytes starting /// at the specified [byteOffset] in this object, in unsigned binary /// form. /// /// The return value will be between 0 and 264 - 1, inclusive. /// /// The [byteOffset] must be non-negative, and /// `byteOffset + 8` must be less than or equal to the length of this object.nnnnnnnnnnpp/// Sets the eight bytes starting at the specified [byteOffset] in this object /// to the unsigned binary representation of the specified [value], /// which must fit in eight bytes. /// /// In other words, [value] must be between /// 0 and 264 - 1, inclusive. /// /// The [byteOffset] must be non-negative, and /// `byteOffset + 8` must be less than or equal to the length of this object.pppp pppppppppցr"r"8/// 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). /// /// The [byteOffset] must be non-negative, and /// `byteOffset + 4` must be less than or equal to the length of this object.r-r2r1r>rFrErNrTrUr_uuu/// Sets the four bytes starting at the specified [byteOffset] in this /// object to the IEEE 754 single-precision binary floating-point /// (binary32) representation of the specified [value]. /// /// **Note that this method can lose precision.** The input [value] is /// a 64-bit floating point value, which will be converted to 32-bit /// floating point value by IEEE 754 rounding rules before it is stored. /// If [value] cannot be represented exactly as a binary32, it will be /// converted to the nearest binary32 value. If two binary32 values are /// equally close, the one whose least significant bit is zero will be used. /// Note that finite (but large) values can be converted to infinity, and /// small non-zero values can be converted to zero. /// /// The [byteOffset] must be non-negative, and /// `byteOffset + 4` must be less than or equal to the length of this object.vvvv vvv"v*v)v2v8v9vCww9/// The floating point number represented by the eight bytes at /// the specified [byteOffset] in this object, in IEEE 754 /// double-precision binary floating-point format (binary64). /// /// The [byteOffset] must be non-negative, and /// `byteOffset + 8` must be less than or equal to the length of this object.wwwwwwwwwẃy!y!B/// Sets the eight bytes starting at the specified [byteOffset] in this /// object to the IEEE 754 double-precision binary floating-point /// (binary64) representation of the specified [value]. /// /// The [byteOffset] must be non-negative, and /// `byteOffset + 8` must be less than or equal to the length of this object.y,y1y0y< yDyCyKySyRy[yaybyl{P{P/// A fixed-length list of 8-bit signed integers. /// /// For long lists, this implementation can be considerably /// more space- and time-efficient than the default [List] implementation. /// /// Integers stored in the list are truncated to their low eight bits, /// interpreted as a signed 8-bit two's complement integer with values in the /// range -128 to +127. /// /// It is a compile-time error for a class to attempt to extend or implement /// `Int8List`.{v|P|P|X/// Creates an [Int8List] of the specified length (in elements), all of /// whose elements are initially zero. /// /// The list is backed by a [ByteBuffer] containing precisely [length] bytes.|Y |^|]|i}}}}}ρ;/// Creates a [Int8List] with the same length as the [elements] list /// and copies over the elements. /// /// Values are truncated to fit in the list when they are copied, /// the same way storing values truncates them. /// /// The list is backed by a [ByteBuffer] containing precisely `elements.length` /// bytes.}}}}-56:6/// Creates an [Int8List] _view_ of the specified region in [buffer]. /// /// Changes in the [Int8List] 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 provided, /// the view extends to the end of the byte buffer. /// /// The [offsetInBytes] and [length] must be non-negative, and /// [offsetInBytes] + ([length] * [bytesPerElement]) must be less than or /// equal to the length of [buffer]. /// /// Note that when creating a view from a [TypedData] list or byte data, /// that list or byte data may itself be a view on a larger buffer /// with a [TypedData.offsetInBytes] greater than zero. /// Merely doing `Int8List.view(other.buffer, 0, count)` may not /// point to the bytes you intended. Instead you may need to do: /// ```dart /// Int8List.view(other.buffer, other.offsetInBytes, count) /// ``` /// Alternatively, use [Int8List.sublistView] /// which includes this computation: /// ```dart /// Int8List.sublistView(other, 0, count); /// ``` /// (The third argument is an end index rather than a length, so if /// you start from a position greater than zero, you need not /// reduce the count correspondingly).@LKY^]t zymĄP/// Creates an [Int8List] view on a range of elements of [data]. /// /// Creates a view on the range of `data.buffer` which corresponds /// to the elements of [data] from [start] until [end]. /// If [data] is a typed data list, like [Uint16List], then the view is on /// the bytes of the elements with indices from [start] until [end]. /// If [data] is a [ByteData], it's treated like a list of bytes. /// /// If provided, [start] and [end] must satisfy /// /// 0 ≤ `start` ≤ `end` ≤ *elementCount* /// /// where *elementCount* is the number of elements in [data], which /// is the same as the [List.length] of a typed data list. /// /// If omitted, [start] defaults to zero and [end] to *elementCount*. $Y\\(/// A read-only view of this [Int8List];CDIOJuP/// Creates a new list containing the elements between [start] and [end]. /// /// The new list is an `Int8List` containing the elements of this list at /// positions greater than or equal to [start] and less than [end] in the same /// order as they occur in this list. /// /// ```dart /// var numbers = Int8List.fromList([0, 1, 2, 3, 4]); /// print(numbers.sublist(1, 3)); // [1, 2] /// print(numbers.sublist(1, 3).runtimeType); // Int8List /// ``` /// /// If [end] is omitted, it defaults to the [length] of this list. /// /// ```dart /// print(numbers.sublist(1)); // [1, 2, 3, 4] /// ``` /// /// The `start` and `end` positions must satisfy the relations /// 0 ≤ `start` ≤ `end` ≤ `this.length`. /// If `end` is equal to `start`, then the returned list is empty. ǁ/// A fixed-length list of 8-bit unsigned integers. /// /// For long lists, this implementation can be considerably /// more space- and time-efficient than the default [List] implementation. /// /// Integers stored in the list are truncated to their low eight bits, /// interpreted as an unsigned 8-bit integer with values in the /// range 0 to 255. /// /// It is a compile-time error for a class to attempt to extend or implement /// `Uint8List`./// Creates a [Uint8List] of the specified length (in elements), all of /// whose elements are initially zero. /// /// The list is backed by a [ByteBuffer] containing precisely [length] bytes. ⁅@IJRJ;i0/// A read-only view of this [Uint8ClampedList].notzuo/// Creates a new list containing the elements between [start] and [end]. /// /// The new list is a `Uint8ClampedList` containing the elements of this /// list at positions greater than or equal to [start] and less than [end] in /// the same order as they occur in this list. /// /// ```dart /// var numbers = Uint8ClampedList.fromList([0, 1, 2, 3, 4]); /// print(numbers.sublist(1, 3)); // [1, 2] /// print(numbers.sublist(1, 3).runtimeType); // Uint8ClampedList /// ``` /// /// If [end] is omitted, it defaults to the [length] of this list. /// /// ```dart /// print(numbers.sublist(1)); // [1, 2, 3, 4] /// ``` /// /// The `start` and `end` positions must satisfy the relations /// 0 ≤ `start` ≤ `end` ≤ `this.length`. /// If `end` is equal to `start`, then the returned list is empty.  DvRR/// A fixed-length list of 16-bit signed integers that is viewable as a /// [TypedData]. /// /// For long lists, this implementation can be considerably /// more space- and time-efficient than the default [List] implementation. /// /// Integers stored in the list are truncated to their low 16 bits, /// interpreted as a signed 16-bit two's complement integer with values in the /// range -32768 to +32767. /// /// It is a compile-time error for a class to attempt to extend or implement /// `Int16List`.ybbk/// Creates an [Int16List] of the specified length (in elements), all of /// whose elements are initially zero. /// /// The list is backed by a [ByteBuffer] containing precisely /// [length] times 2 bytes.l qp|D/// Creates a [Int16List] with the same length as the [elements] list /// and copies over the elements. /// /// Values are truncated to fit in the list when they are copied, /// the same way storing values truncates them. /// /// The list is backed by a [ByteBuffer] containing precisely /// `elements.length` times 2 bytes. !E/// Creates an [Int16List] _view_ of the specified region in [buffer]. /// /// Changes in the [Int16List] 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 provided, /// the view extends to the end of the byte buffer. /// /// The [offsetInBytes] and [length] must be non-negative, and /// [offsetInBytes] + ([length] * [bytesPerElement]) must be less than or /// equal to the length of [buffer]. /// /// The [offsetInBytes] must be a multiple of [bytesPerElement]. /// /// Note that when creating a view from a [TypedData] list or byte data, /// that list or byte data may itself be a view on a larger buffer /// with a [TypedData.offsetInBytes] greater than zero. /// Merely doing `Int16List.view(other.buffer, 0, count)` may not /// point to the bytes you intended. Instead you may need to do: /// ```dart /// Int16List.view(other.buffer, other.offsetInBytes, count) /// ``` /// Alternatively, use [Int16List.sublistView] /// which includes this computation: /// ```dart /// Int16List.sublistView(other, 0, count); /// ``` /// (The third argument is an end index rather than a length, so if /// you start from a position greater than zero, you need not /// reduce the count correspondingly). 2,/// Creates an [Int16List] view on a range of elements of [data]. /// /// Creates a view on the range of `data.buffer` which corresponds /// to the elements of [data] from [start] until [end]. /// If [data] is a typed data list, like [Uint16List], then the view is on /// the bytes of the elements with indices from [start] until [end]. /// If [data] is a [ByteData], it's treated like a list of bytes. /// /// If provided, [start] and [end] must satisfy /// /// 0 ≤ `start` ≤ `end` ≤ *elementCount* /// /// where *elementCount* is the number of elements in [data], which /// is the same as the [List.length] of a typed data list. /// /// If omitted, [start] defaults to zero and [end] to *elementCount*. /// /// The start and end indices of the range of bytes being viewed must be /// multiples of two. Ǔ$ǤǤǶ["")/// A read-only view of this [Int16List]. ;Tpp/// Creates a new list containing the elements between [start] and [end]. /// /// The new list is an `Int16List` containing the elements of this /// list at positions greater than or equal to [start] and less than [end] in /// the same order as they occur in this list. /// /// ```dart /// var numbers = Int16List.fromList([0, 1, 2, 3, 4]); /// print(numbers.sublist(1, 3)); // [1, 2] /// print(numbers.sublist(1, 3).runtimeType); // Int16List /// ``` /// /// If [end] is omitted, it defaults to the [length] of this list. /// /// ```dart /// print(numbers.sublist(1)); // [1, 2, 3, 4] /// ``` /// /// The `start` and `end` positions must satisfy the relations /// 0 ≤ `start` ≤ `end` ≤ `this.length`. /// If `end` is equal to `start`, then the returned list is empty.x }|DŽNJljǼɹɹ/// A fixed-length list of 16-bit unsigned integers that is viewable as a /// [TypedData]. /// /// For long lists, this implementation can be considerably /// more space- and time-efficient than the default [List] implementation. /// /// Integers stored in the list are truncated to their low 16 bits, /// interpreted as an unsigned 16-bit integer with values in the /// range 0 to 65535. /// /// It is a compile-time error for a class to attempt to extend or implement /// `Uint16List`./// Creates a [Uint16List] of the specified length (in elements), all /// of whose elements are initially zero. /// /// The list is backed by a [ByteBuffer] containing precisely /// [length] times 2 bytes. 偏LVW_WE/// Creates a [Uint16List] with the same length as the [elements] list /// and copies over the elements. /// /// Values are truncated to fit in the list when they are copied, /// the same way storing values truncates them. /// /// The list is backed by a [ByteBuffer] containing precisely /// `elements.length` times 2 bytes.`kjx? *+/+_/// Creates a [Uint16List] _view_ of the specified region in /// the specified byte buffer. /// /// Changes in the [Uint16List] 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 provided, /// the view extends to the end of the byte buffer. /// /// The [offsetInBytes] and [length] must be non-negative, and /// [offsetInBytes] + ([length] * [bytesPerElement]) must be less than or /// equal to the length of [buffer]. /// /// The [offsetInBytes] must be a multiple of [bytesPerElement]. /// /// Note that when creating a view from a [TypedData] list or byte data, /// that list or byte data may itself be a view on a larger buffer /// with a [TypedData.offsetInBytes] greater than zero. /// Merely doing `Uint16List.view(other.buffer, 0, count)` may not /// point to the bytes you intended. Instead you may need to do: /// ```dart /// Uint16List.view(other.buffer, other.offsetInBytes, count) /// ``` /// Alternatively, use [Uint16List.sublistView] /// which includes this computation: /// ```dart /// Uint16List.sublistView(other, 0, count); /// ``` /// (The third argument is an end index rather than a length, so if /// you start from a position greater than zero, you need not /// reduce the count correspondingly).5A@NSRi onbһ !,!,/// Creates a [Uint16List] view on a range of elements of [data]. /// /// Creates a view on the range of `data.buffer` which corresponds /// to the elements of [data] from [start] until [end]. /// If [data] is a typed data list, like [Uint16List], then the view is on /// the bytes of the elements with indices from [start] until [end]. /// If [data] is a [ByteData], it's treated like a list of bytes. /// /// If provided, [start] and [end] must satisfy /// /// 0 ≤ `start` ≤ `end` ≤ *elementCount* /// /// where *elementCount* is the number of elements in [data], which /// is the same as the [List.length] of a typed data list. /// /// If omitted, [start] defaults to zero and [end] to *elementCount*. /// /// The start and end indices of the range of bytes being viewed must be /// multiples of two.-87> CBMSRJ#$44Fg]دد*/// A read-only view of this [Uint16List].ؚؔؕؠ؛ȃW/// Creates a new list containing the elements between [start] and [end]. /// /// The new list is a `Uint16List` containing the elements of this /// list at positions greater than or equal to [start] and less than [end] in /// the same order as they occur in this list. /// /// ```dart /// var numbers = Uint16List.fromList([0, 1, 2, 3, 4]); /// print(numbers.sublist(1, 3)); // [1, 2] /// print(numbers.sublist(1, 3).runtimeType); // Uint16List /// ``` /// /// If [end] is omitted, it defaults to the [length] of this list. /// /// ```dart /// print(numbers.sublist(1)); // [1, 2, 3, 4] /// ``` /// /// The `start` and `end` positions must satisfy the relations /// 0 ≤ `start` ≤ `end` ≤ `this.length`. /// If `end` is equal to `start`, then the returned list is empty.  Lcc/// A fixed-length list of 32-bit signed integers that is viewable as a /// [TypedData]. /// /// For long lists, this implementation can be considerably /// more space- and time-efficient than the default [List] implementation. /// /// Integers stored in the list are truncated to their low 32 bits, /// interpreted as a signed 32-bit two's complement integer with values in the /// range -2147483648 to 2147483647. /// /// It is a compile-time error for a class to attempt to extend or implement /// `Int32List`.ފss|/// Creates an [Int32List] of the specified length (in elements), all of /// whose elements are initially zero. /// /// The list is backed by a [ByteBuffer] containing precisely /// [length] times 4 bytes.} ߂߁ߍD/// Creates a [Int32List] with the same length as the [elements] list /// and copies over the elements. /// /// Values are truncated to fit in the list when they are copied, /// the same way storing values truncates them. /// /// The list is backed by a [ByteBuffer] containing precisely /// `elements.length` times 4 bytes.!洅E/// Creates an [Int32List] _view_ of the specified region in [buffer]. /// /// Changes in the [Int32List] 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 provided, /// the view extends to the end of the byte buffer. /// /// The [offsetInBytes] and [length] must be non-negative, and /// [offsetInBytes] + ([length] * [bytesPerElement]) must be less than or /// equal to the length of [buffer]. /// /// The [offsetInBytes] must be a multiple of [bytesPerElement]. /// /// Note that when creating a view from a [TypedData] list or byte data, /// that list or byte data may itself be a view on a larger buffer /// with a [TypedData.offsetInBytes] greater than zero. /// Merely doing `Int32List.view(other.buffer, 0, count)` may not /// point to the bytes you intended. Instead you may need to do: /// ```dart /// Int32List.view(other.buffer, other.offsetInBytes, count) /// ``` /// Alternatively, use [Int32List.sublistView] /// which includes this computation: /// ```dart /// Int32List.sublistView(other, 0, count); /// ``` /// (The third argument is an end index rather than a length, so if /// you start from a position greater than zero, you need not /// reduce the count correspondingly). Cꩃ-/// Creates an [Int32List] view on a range of elements of [data]. /// /// Creates a view on the range of `data.buffer` which corresponds /// to the elements of [data] from [start] until [end]. /// If [data] is a typed data list, like [Uint16List], then the view is on /// the bytes of the elements with indices from [start] until [end]. /// If [data] is a [ByteData], it's treated like a list of bytes. /// /// If provided, [start] and [end] must satisfy /// /// 0 ≤ `start` ≤ `end` ≤ *elementCount* /// /// where *elementCount* is the number of elements in [data], which /// is the same as the [List.length] of a typed data list. /// /// If omitted, [start] defaults to zero and [end] to *elementCount*. /// /// The start and end indices of the range of bytes being viewed must be /// multiples of four. $[44)/// A read-only view of this [Int16List]. &!MT/// Creates a new list containing the elements between [start] and [end]. /// /// The new list is an `Int32List` containing the elements of this /// list at positions greater than or equal to [start] and less than [end] in /// the same order as they occur in this list. /// /// ```dart /// var numbers = Int32List.fromList([0, 1, 2, 3, 4]); /// print(numbers.sublist(1, 3)); // [1, 2] /// print(numbers.sublist(1, 3).runtimeType); // Int32List /// ``` /// /// If [end] is omitted, it defaults to the [length] of this list. /// /// ```dart /// print(numbers.sublist(1)); // [1, 2, 3, 4] /// ``` /// /// The `start` and `end` positions must satisfy the relations /// 0 ≤ `start` ≤ `end` ≤ `this.length`. /// If `end` is equal to `start`, then the returned list is empty. ΔЁ/// A fixed-length list of 32-bit unsigned integers that is viewable as a /// [TypedData]. /// /// For long lists, this implementation can be considerably /// more space- and time-efficient than the default [List] implementation. /// /// Integers stored in the list are truncated to their low 32 bits, /// interpreted as an unsigned 32-bit integer with values in the /// range 0 to 4294967295. /// /// It is a compile-time error for a class to attempt to extend or implement /// `Uint32List`./// Creates a [Uint32List] of the specified length (in elements), all /// of whose elements are initially zero. /// /// The list is backed by a [ByteBuffer] containing precisely /// [length] times 4 bytes. cmnvnE/// Creates a [Uint32List] with the same length as the [elements] list /// and copies over the elements. /// /// Values are truncated to fit in the list when they are copied, /// the same way storing values truncates them. /// /// The list is backed by a [ByteBuffer] containing precisely /// `elements.length` times 4 bytes.w?7ABFB_/// Creates a [Uint32List] _view_ of the specified region in /// the specified byte buffer. /// /// Changes in the [Uint32List] 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 provided, /// the view extends to the end of the byte buffer. /// /// The [offsetInBytes] and [length] must be non-negative, and /// [offsetInBytes] + ([length] * [bytesPerElement]) must be less than or /// equal to the length of [buffer]. /// /// The [offsetInBytes] must be a multiple of [bytesPerElement]. /// /// Note that when creating a view from a [TypedData] list or byte data, /// that list or byte data may itself be a view on a larger buffer /// with a [TypedData.offsetInBytes] greater than zero. /// Merely doing `Uint32List.view(other.buffer, 0, count)` may not /// point to the bytes you intended. Instead you may need to do: /// ```dart /// Uint32List.view(other.buffer, other.offsetInBytes, count) /// ``` /// Alternatively, use [Uint32List.sublistView] /// which includes this computation: /// ```dart /// Uint32List.sublistView(other, 0, count); /// ``` /// (The third argument is an end index rather than a length, so if /// you start from a position greater than zero, you need not /// reduce the count correspondingly).LXWeji y҅.89D9-/// Creates a [Uint32List] view on a range of elements of [data]. /// /// Creates a view on the range of `data.buffer` which corresponds /// to the elements of [data] from [start] until [end]. /// If [data] is a typed data list, like [Uint16List], then the view is on /// the bytes of the elements with indices from [start] until [end]. /// If [data] is a [ByteData], it's treated like a list of bytes. /// /// If provided, [start] and [end] must satisfy /// /// 0 ≤ `start` ≤ `end` ≤ *elementCount* /// /// where *elementCount* is the number of elements in [data], which /// is the same as the [List.length] of a typed data list. /// /// If omitted, [start] defaults to zero and [end] to *elementCount*. /// /// The start and end indices of the range of bytes being viewed must be /// multiples of four.EPOV [Zekjb;$LL^]*/// A read-only view of this [Uint32List].W/// Creates a new list containing the elements between [start] and [end]. /// /// The new list is a `Uint32List` containing the elements of this /// list at positions greater than or equal to [start] and less than [end] in /// the same order as they occur in this list. /// /// ```dart /// var numbers = Uint32List.fromList([0, 1, 2, 3, 4]); /// print(numbers.sublist(1, 3)); // [1, 2] /// print(numbers.sublist(1, 3).runtimeType); // Uint32List /// ``` /// /// If [end] is omitted, it defaults to the [length] of this list. /// /// ```dart /// print(numbers.sublist(1)); // [1, 2, 3, 4] /// ``` /// /// The `start` and `end` positions must satisfy the relations /// 0 ≤ `start` ≤ `end` ≤ `this.length`. /// If `end` is equal to `start`, then the returned list is empty. %$,21d/// A fixed-length list of 64-bit signed integers that is viewable as a /// [TypedData]. /// /// For long lists, this implementation can be considerably /// more space- and time-efficient than the default [List] implementation. /// /// Integers stored in the list are truncated to their low 64 bits, /// interpreted as a signed 64-bit two's complement integer with values in the /// range -9223372036854775808 to +9223372036854775807. /// /// It is a compile-time error for a class to attempt to extend or implement /// `Int64List`./// Creates an [Int64List] of the specified length (in elements), all of /// whose elements are initially zero. /// /// The list is backed by a [ByteBuffer] containing precisely /// [length] times 8 bytes.   ' ( 0 (D/// Creates a [Int64List] with the same length as the [elements] list /// and copies over the elements. /// /// Values are truncated to fit in the list when they are copied, /// the same way storing values truncates them. /// /// The list is backed by a [ByteBuffer] containing precisely /// `elements.length` times 8 bytes. 1 < ; I!߅E/// Creates an [Int64List] _view_ of the specified region in [buffer]. /// /// Changes in the [Int64List] 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 provided, /// the view extends to the end of the byte buffer. /// /// The [offsetInBytes] and [length] must be non-negative, and /// [offsetInBytes] + ([length] * [bytesPerElement]) must be less than or /// equal to the length of [buffer]. /// /// The [offsetInBytes] must be a multiple of [bytesPerElement]. /// /// Note that when creating a view from a [TypedData] list or byte data, /// that list or byte data may itself be a view on a larger buffer /// with a [TypedData.offsetInBytes] greater than zero. /// Merely doing `Int64List.view(other.buffer, 0, count)` may not /// point to the bytes you intended. Instead you may need to do: /// ```dart /// Int64List.view(other.buffer, other.offsetInBytes, count) /// ``` /// Alternatively, use [Int64List.sublistView] /// which includes this computation: /// ```dart /// Int64List.sublistView(other, 0, count); /// ``` /// (The third argument is an end index rather than a length, so if /// you start from a position greater than zero, you need not /// reduce the count correspondingly). #"nՃ./// Creates an [Int64List] view on a range of elements of [data]. /// /// Creates a view on the range of `data.buffer` which corresponds /// to the elements of [data] from [start] until [end]. /// If [data] is a typed data list, like [Uint16List], then the view is on /// the bytes of the elements with indices from [start] until [end]. /// If [data] is a [ByteData], it's treated like a list of bytes. /// /// If provided, [start] and [end] must satisfy /// /// 0 ≤ `start` ≤ `end` ≤ *elementCount* /// /// where *elementCount* is the number of elements in [data], which /// is the same as the [List.length] of a typed data list. /// /// If omitted, [start] defaults to zero and [end] to *elementCount*. /// /// The start and end indices of the range of bytes being viewed must be /// multiples of eight. $[``)/// A read-only view of this [Int64List].FGLRMyT/// Creates a new list containing the elements between [start] and [end]. /// /// The new list is an `Int64List` containing the elements of this /// list at positions greater than or equal to [start] and less than [end] in /// the same order as they occur in this list. /// /// ```dart /// var numbers = Int64List.fromList([0, 1, 2, 3, 4]); /// print(numbers.sublist(1, 3)); // [1, 2] /// print(numbers.sublist(1, 3).runtimeType); // Int64List /// ``` /// /// If [end] is omitted, it defaults to the [length] of this list. /// /// ```dart /// print(numbers.sublist(1)); // [1, 2, 3, 4] /// ``` /// /// The `start` and `end` positions must satisfy the relations /// 0 ≤ `start` ≤ `end` ≤ `this.length`. /// If `end` is equal to `start`, then the returned list is empty. /// A fixed-length list of 64-bit unsigned integers that is viewable as a /// [TypedData]. /// /// For long lists, this implementation can be considerably /// more space- and time-efficient than the default [List] implementation. /// /// Integers stored in the list are truncated to their low 64 bits, /// interpreted as an unsigned 64-bit integer with values in the /// range 0 to 18446744073709551615. /// /// It is a compile-time error for a class to attempt to extend or implement /// `Uint64List`..!/// Creates a [Uint64List] of the specified length (in elements), all /// of whose elements are initially zero. /// /// The list is backed by a [ByteBuffer] containing precisely /// [length] times 8 bytes." '&2E/// Creates a [Uint64List] with the same length as the [elements] list /// and copies over the elements. /// /// Values are truncated to fit in the list when they are copied, /// the same way storing values truncates them. /// /// The list is backed by a [ByteBuffer] containing precisely /// `elements.length` times 8 bytes.ņ@$n$x$y$}$y`/// Creates an [Uint64List] _view_ of the specified region in /// the specified byte buffer. /// /// Changes in the [Uint64List] 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 provided, /// the view extends to the end of the byte buffer. /// /// The [offsetInBytes] and [length] must be non-negative, and /// [offsetInBytes] + ([length] * [bytesPerElement]) must be less than or /// equal to the length of [buffer]. /// /// The [offsetInBytes] must be a multiple of [bytesPerElement]. /// /// Note that when creating a view from a [TypedData] list or byte data, /// that list or byte data may itself be a view on a larger buffer /// with a [TypedData.offsetInBytes] greater than zero. /// Merely doing `Uint64List.view(other.buffer, 0, count)` may not /// point to the bytes you intended. Instead you may need to do: /// ```dart /// Uint64List.view(other.buffer, other.offsetInBytes, count) /// ``` /// Alternatively, use [Uint64List.sublistView] /// which includes this computation: /// ```dart /// Uint64List.sublistView(other, 0, count); /// ``` /// (The third argument is an end index rather than a length, so if /// you start from a position greater than zero, you need not /// reduce the count correspondingly).$$$$$$$ $$$% (f(p(q(|(q./// Creates a [Uint64List] view on a range of elements of [data]. /// /// Creates a view on the range of `data.buffer` which corresponds /// to the elements of [data] from [start] until [end]. /// If [data] is a typed data list, like [Uint16List], then the view is on /// the bytes of the elements with indices from [start] until [end]. /// If [data] is a [ByteData], it's treated like a list of bytes. /// /// If provided, [start] and [end] must satisfy /// /// 0 ≤ `start` ≤ `end` ≤ *elementCount* /// /// where *elementCount* is the number of elements in [data], which /// is the same as the [List.length] of a typed data list. /// /// If omitted, [start] defaults to zero and [end] to *elementCount*. /// /// The start and end indices of the range of bytes being viewed must be /// multiples of eight.(}((( ((((((.s$...*]***/// A read-only view of this [Uint64List].*****+W.P.P/// Creates a new list containing the elements between [start] and [end]. /// /// The new list is a `Uint64List` containing the elements of this /// list at positions greater than or equal to [start] and less than [end] in /// the same order as they occur in this list. /// /// ```dart /// var numbers = Uint64List.fromList([0, 1, 2, 3, 4]); /// print(numbers.sublist(1, 3)); // [1, 2] /// print(numbers.sublist(1, 3).runtimeType); // Uint64List /// ``` /// /// If [end] is omitted, it defaults to the [length] of this list. /// /// ```dart /// print(numbers.sublist(1)); // [1, 2, 3, 4] /// ``` /// /// The `start` and `end` positions must satisfy the relations /// 0 ≤ `start` ≤ `end` ≤ `this.length`. /// If `end` is equal to `start`, then the returned list is empty..X .].\.d.j.i.00ł/// A fixed-length list of IEEE 754 single-precision binary floating-point /// numbers that is viewable as a [TypedData]. /// /// For long lists, this /// implementation can be considerably more space- and time-efficient than /// the default [List] implementation. /// /// Double values stored in the list are converted to the nearest /// single-precision value. Values read are converted to a double /// value with the same value. /// /// It is a compile-time error for a class to attempt to extend or implement /// `Float32List`.0111/// Creates a [Float32List] of the specified length (in elements), all of /// whose elements are initially zero. /// /// The list is backed by a [ByteBuffer] containing precisely /// [length] times 4 bytes.1 1113^3i3j3r3jF/// Creates a [Float32List] with the same length as the [elements] list /// and copies over the elements. /// /// Values are truncated to fit in the list when they are copied, /// the same way storing values truncates them. /// /// The list is backed by a [ByteBuffer] containing precisely /// `elements.length` times 4 bytes.3s33309%90919591P/// Creates a [Float32List] _view_ of the specified region in [buffer]. /// /// Changes in the [Float32List] 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 provided, /// the view extends to the end of the byte buffer. /// /// The [offsetInBytes] and [length] must be non-negative, and /// [offsetInBytes] + ([length] * [bytesPerElement]) must be less than or /// equal to the length of [buffer]. /// /// The [offsetInBytes] must be a multiple of [bytesPerElement]. /// /// Note that when creating a view from a [TypedData] list or byte data, /// that list or byte data may itself be a view on a larger buffer /// with a [TypedData.offsetInBytes] greater than zero. /// Merely doing `Float32List.view(other.buffer, 0, count)` may not /// point to the bytes you intended. Instead you may need to do: /// ```dart /// Float32List.view(other.buffer, other.offsetInBytes, count) /// ``` /// Alternatively, use [Float32List.sublistView] /// which includes this computation: /// ```dart /// Float32List.sublistView(other, 0, count); /// ``` /// (The third argument is an end index rather than a length, so if /// you start from a position greater than zero, you need not /// reduce the count correspondingly).9;9G9F9T9Y9X9o 9u9t9h9…= =+=,=7=,//// Creates an [Float32List] view on a range of elements of [data]. /// /// Creates a view on the range of `data.buffer` which corresponds /// to the elements of [data] from [start] until [end]. /// If [data] is a typed data list, like [Uint16List], then the view is on /// the bytes of the elements with indices from [start] until [end]. /// If [data] is a [ByteData], it's treated like a list of bytes. /// /// If provided, [start] and [end] must satisfy /// /// 0 ≤ `start` ≤ `end` ≤ *elementCount* /// /// where *elementCount* is the number of elements in [data], which /// is the same as the [List.length] of a typed data list. /// /// If omitted, [start] defaults to zero and [end] to *elementCount*. /// /// The start and end indices of the range of bytes being viewed must be /// multiples of four.=8=C=B=I =N=M=X=^=]=UCK$C\C\Cn?s_??+/// A read-only view of this [Float32List].??????փqC(C(!/// Creates a new list containing the elements between [start] and [end]. /// /// The new list is a `Float32List` containing the elements of this /// list at positions greater than or equal to [start] and less than [end] in /// the same order as they occur in this list. /// /// ```dart /// var numbers = Float32List.fromList([0.0, 1.0, 2.0, 3.0, 4.0]); /// print(numbers.sublist(1, 3)); // [1.0, 2.0] /// print(numbers.sublist(1, 3).runtimeType); // Float32List /// ``` /// /// If [end] is omitted, it defaults to the [length] of this list. /// /// ```dart /// print(numbers.sublist(1)); // [1.0, 2.0, 3.0, 4.0] /// ``` /// /// The `start` and `end` positions must satisfy the relations /// 0 ≤ `start` ≤ `end` ≤ `this.length`. /// If `end` is equal to `start`, then the returned list is empty.C0 C5C4C<CBCACtDDm/// A fixed-length list of IEEE 754 double-precision binary floating-point /// numbers that is viewable as a [TypedData]. /// /// For long lists, this /// implementation can be considerably more space- and time-efficient than /// the default [List] implementation. /// /// It is a compile-time error for a class to attempt to extend or implement /// `Float64List`.E"F F F/// Creates a [Float64List] of the specified length (in elements), all of /// whose elements are initially zero. /// /// The list is backed by a [ByteBuffer] containing precisely /// [length] times 8 bytes.F FFF(GGG G(G /// Creates a [Float64List] with the same length as the [elements] list /// and copies over the elements. /// /// The list is backed by a [ByteBuffer] containing precisely /// `elements.length` times 8 bytes.G)G7G6GD0LLLLLP/// Creates a [Float64List] _view_ of the specified region in [buffer]. /// /// Changes in the [Float64List] 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 provided, /// the view extends to the end of the byte buffer. /// /// The [offsetInBytes] and [length] must be non-negative, and /// [offsetInBytes] + ([length] * [bytesPerElement]) must be less than or /// equal to the length of [buffer]. /// /// The [offsetInBytes] must be a multiple of [bytesPerElement]. /// /// Note that when creating a view from a [TypedData] list or byte data, /// that list or byte data may itself be a view on a larger buffer /// with a [TypedData.offsetInBytes] greater than zero. /// Merely doing `Float64List.view(other.buffer, 0, count)` may not /// point to the bytes you intended. Instead you may need to do: /// ```dart /// Float64List.view(other.buffer, other.offsetInBytes, count) /// ``` /// Alternatively, use [Float64List.sublistView] /// which includes this computation: /// ```dart /// Float64List.sublistView(other, 0, count); /// ``` /// (The third argument is an end index rather than a length, so if /// you start from a position greater than zero, you need not /// reduce the count correspondingly).LLLM MMM% M+M*MMxPPPPP//// Creates a [Float64List] view on a range of elements of [data]. /// /// Creates a view on the range of `data.buffer` which corresponds /// to the elements of [data] from [start] until [end]. /// If [data] is a typed data list, like [Uint16List], then the view is on /// the bytes of the elements with indices from [start] until [end]. /// If [data] is a [ByteData], it's treated like a list of bytes. /// /// If provided, [start] and [end] must satisfy /// /// 0 ≤ `start` ≤ `end` ≤ *elementCount* /// /// where *elementCount* is the number of elements in [data], which /// is the same as the [List.length] of a typed data list. /// /// If omitted, [start] defaults to zero and [end] to *elementCount*. /// /// The start and end indices of the range of bytes being viewed must be /// multiples of eight.PPPP QQQQQQ W$WWW$S)_SsSs+/// A read-only view of this [Float64List].SWSXS]ScS^SqVVރ!/// Creates a new list containing the elements between [start] and [end]. /// /// The new list is a `Float64List` containing the elements of this /// list at positions greater than or equal to [start] and less than [end] in /// the same order as they occur in this list. /// /// ```dart /// var numbers = Float64List.fromList([0.0, 1.0, 2.0, 3.0, 4.0]); /// print(numbers.sublist(1, 3)); // [1.0, 2.0] /// print(numbers.sublist(1, 3).runtimeType); // Float64List /// ``` /// /// If [end] is omitted, it defaults to the [length] of this list. /// /// ```dart /// print(numbers.sublist(1)); // [1.0, 2.0, 3.0, 4.0] /// ``` /// /// The `start` and `end` positions must satisfy the relations /// 0 ≤ `start` ≤ `end` ≤ `this.length`. /// If `end` is equal to `start`, then the returned list is empty.V VVVVVW*wXXG/// A fixed-length list of [Float32x4] numbers that is viewable as a /// [TypedData]. /// /// For long lists, this implementation will be considerably more /// space- and time-efficient than the default [List] implementation. /// /// It is a compile-time error for a class to attempt to extend or implement /// `Float32x4List`.X́YYY/// Creates a [Float32x4List] of the specified length (in elements), /// all of whose elements are initially zero. /// /// The list is backed by a [ByteBuffer] containing precisely /// [length] times 16 bytes.Y YYYׁ ZZZZZԀ/// Creates a [Float32x4List] with the same length as the [elements] list /// and copies over the elements. /// /// The list is backed by a [ByteBuffer] containing precisely /// `elements.length` times 16 bytes.ZZZZ@`````\/// Creates a [Float32x4List] _view_ of the specified region in [buffer]. /// /// Changes in the [Float32x4List] 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 provided, /// the view extends to the end of the byte buffer. /// /// The [offsetInBytes] and [length] must be non-negative, and /// [offsetInBytes] + ([length] * [bytesPerElement]) must be less than or /// equal to the length of [buffer]. /// /// The [offsetInBytes] must be a multiple of [bytesPerElement]. /// /// Note that when creating a view from a [TypedData] list or byte data, /// that list or byte data may itself be a view on a larger buffer /// with a [TypedData.offsetInBytes] greater than zero. /// Merely doing `Float32x4List.view(other.buffer, 0, count)` may not /// point to the bytes you intended. Instead you may need to do: /// ```dart /// Float32x4List.view(other.buffer, other.offsetInBytes, count) /// ``` /// Alternatively, use [Float32x4List.sublistView] /// which includes this computation: /// ```dart /// Float32x4List.sublistView(other, 0, count); /// ``` /// (The third argument is an end index rather than a length, so if /// you start from a position greater than zero, you need not /// reduce the count correspondingly).``````` ```a?ddddd3/// Creates a [Float32x4List] view on a range of elements of [data]. /// /// Creates a view on the range of `data.buffer` which corresponds /// to the elements of [data] from [start] until [end]. /// If [data] is a typed data list, like [Uint16List], then the view is on /// the bytes of the elements with indices from [start] until [end]. /// If [data] is a [ByteData], it's treated like a list of bytes. /// /// If provided, [start] and [end] must satisfy /// /// 0 ≤ `start` ≤ `end` ≤ *elementCount* /// /// where *elementCount* is the number of elements in [data], which /// is the same as the [List.length] of a typed data list. /// /// If omitted, [start] defaults to zero and [end] to *elementCount*. /// /// The start and end indices of the range of bytes being viewed must be /// multiples of sixteen.dddd ddddddly%lllfcgFgF-/// A read-only view of this [Float32x4List].g(g)g.g4g/g_hDhD/// The concatenation of this list and [other]. /// /// If [other] is also a [Float32x4List], the result is a new [Float32x4List], /// otherwise the result is a normal growable `List`.hFhWhVhalVlV/// Creates a new list containing the elements between [start] and [end]. /// /// The new list is a `Float32x4List` containing the elements of this /// list at positions greater than or equal to [start] and less than [end] in /// the same order as they occur in this list. /// /// ```dart /// var numbers = Float32x4List.fromList([ /// Float32x4(0, 1, 2, 3), /// Float32x4(1, 2, 3, 4), /// Float32x4(2, 3, 4, 5), /// Float32x4(3, 4, 5, 6), /// Float32x4(4, 5, 6, 7), /// ]); /// print(numbers.sublist(1, 2)); // [Float32x4(1, 2, 3, 4)] /// print(numbers.sublist(1, 2).runtimeType); // Float32x4List /// ``` /// /// If [end] is omitted, it defaults to the [length] of this list. /// /// ```dart /// print(numbers.sublist(4)); // [Float32x4(4, 5, 6, 7)] /// ``` /// /// The `start` and `end` positions must satisfy the relations /// 0 ≤ `start` ≤ `end` ≤ `this.length`. /// If `end` is equal to `start`, then the returned list is empty.l^ lclbljlplolmm/// A fixed-length list of [Int32x4] numbers that is viewable as a /// [TypedData]. /// /// For long lists, this implementation will be considerably more /// space- and time-efficient than the default [List] implementation.mՁnnn/// Creates a [Int32x4List] of the specified length (in elements), /// all of whose elements are initially zero. /// /// The list is backed by a [ByteBuffer] containing precisely /// [length] times 16 bytes.n nnn܁oooooՀ/// Creates a [Int32x4List] with the same length as the [elements] list /// and copies over the elements. /// /// The list is backed by a [ByteBuffer] containing precisely /// `elements.length` times 16 bytes.oooo0uuuuuP/// Creates a [Int32x4List] _view_ of the specified region in [buffer]. /// /// Changes in the [Int32x4List] 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 provided, /// the view extends to the end of the byte buffer. /// /// The [offsetInBytes] and [length] must be non-negative, and /// [offsetInBytes] + ([length] * [bytesPerElement]) must be less than or /// equal to the length of [buffer]. /// /// The [offsetInBytes] must be a multiple of [bytesPerElement]. /// /// Note that when creating a view from a [TypedData] list or byte data, /// that list or byte data may itself be a view on a larger buffer /// with a [TypedData.offsetInBytes] greater than zero. /// Merely doing `Int32x4List.view(other.buffer, 0, count)` may not /// point to the bytes you intended. Instead you may need to do: /// ```dart /// Int32x4List.view(other.buffer, other.offsetInBytes, count) /// ``` /// Alternatively, use [Int32x4List.sublistView] /// which includes this computation: /// ```dart /// Int32x4List.sublistView(other, 0, count); /// ``` /// (The third argument is an end index rather than a length, so if /// you start from a position greater than zero, you need not /// reduce the count correspondingly).uuuuuuu uuuv.yyyyy2/// Creates an [Int32x4List] view on a range of elements of [data]. /// /// Creates a view on the range of `data.buffer` which corresponds /// to the elements of [data] from [start] until [end]. /// If [data] is a typed data list, like [Uint16List], then the view is on /// the bytes of the elements with indices from [start] until [end]. /// If [data] is a [ByteData], it's treated like a list of bytes. /// /// If provided, [start] and [end] must satisfy /// /// 0 ≤ `start` ≤ `end` ≤ *elementCount* /// /// where *elementCount* is the number of elements in [data], which /// is the same as the [List.length] of a typed data list. /// /// If omitted, [start] defaults to zero and [end] to *elementCount*. /// /// The start and end indices of the range of bytes being viewed must be /// multiples of sixteen.yyyy yyyyyyU%ffx{_|,|,+/// A read-only view of this [Int32x4List].||||||E}"}"/// The concatenation of this list and [other]. /// /// If [other] is also a [Int32x4List], the result is a new [Int32x4List], /// otherwise the result is a normal growable `List`.}$}3}2}=22/// Creates a new list containing the elements between [start] and [end]. /// /// The new list is an `Int32x4List` containing the elements of this /// list at positions greater than or equal to [start] and less than [end] in /// the same order as they occur in this list. /// /// ```dart /// var numbers = Int32x4List.fromList([ /// Int32x4(0, 1, 2, 3), /// Int32x4(1, 2, 3, 4), /// Int32x4(2, 3, 4, 5), /// Int32x4(3, 4, 5, 6), /// Int32x4(4, 5, 6, 7), /// ]); /// print(numbers.sublist(1, 2)); // [Int32x4(1, 2, 3, 4)] /// print(numbers.sublist(1, 2).runtimeType); // Int32x4List /// ``` /// /// If [end] is omitted, it defaults to the [length] of this list. /// /// ```dart /// print(numbers.sublist(3)); // [Int32x4(3, 4, 5, 6), Int32x4(4, 5, 6, 7)] /// ``` /// /// The `start` and `end` positions must satisfy the relations /// 0 ≤ `start` ≤ `end` ≤ `this.length`. /// If `end` is equal to `start`, then the returned list is empty.: ?>FLKx܁G/// A fixed-length list of [Float64x2] numbers that is viewable as a /// [TypedData]. /// /// For long lists, this implementation will be considerably more /// space- and time-efficient than the default [List] implementation. /// /// It is a compile-time error for a class to attempt to extend or implement /// `Float64x2List`.!#/// Creates a [Float64x2List] of the specified length (in elements), /// all of whose elements have all lanes set to zero. /// /// The list is backed by a [ByteBuffer] containing precisely /// [length] times 16 bytes.$ )(4 #0191/// Creates a [Float64x2List] with the same length as the [elements] list /// and copies over the elements. /// /// The list is backed by a [ByteBuffer] containing precisely /// `elements.length` times 16 bytes.:KJZ@   \/// Creates a [Float64x2List] _view_ of the specified region in [buffer]. /// /// Changes in the [Float64x2List] 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 provided, /// the view extends to the end of the byte buffer. /// /// The [offsetInBytes] and [length] must be non-negative, and /// [offsetInBytes] + ([length] * [bytesPerElement]) must be less than or /// equal to the length of [buffer]. /// /// The [offsetInBytes] must be a multiple of [bytesPerElement]. /// /// Note that when creating a view from a [TypedData] list or byte data, /// that list or byte data may itself be a view on a larger buffer /// with a [TypedData.offsetInBytes] greater than zero. /// Merely doing `Float64x2List.view(other.buffer, 0, count)` may not /// point to the bytes you intended. Instead you may need to do: /// ```dart /// Float64x2List.view(other.buffer, other.offsetInBytes, count) /// ``` /// Alternatively, use [Float64x2List.sublistView] /// which includes this computation: /// ```dart /// Float64x2List.sublistView(other, 0, count); /// ``` /// (The third argument is an end index rather than a length, so if /// you start from a position greater than zero, you need not /// reduce the count correspondingly).! .32I ONB4/// Creates an [Float64x2List] view on a range of elements of [data]. /// /// Creates a view on the range of `data.buffer` which corresponds /// to the elements of [data] from [start] until [end]. /// If [data] is a typed data list, like [Uint16List], then the view is on /// the bytes of the elements with indices from [start] until [end]. /// If [data] is a [ByteData], it's treated like a list of bytes. /// /// If provided, [start] and [end] must satisfy /// /// 0 ≤ `start` ≤ `end` ≤ *elementCount* /// /// where *elementCount* is the number of elements in [data], which /// is the same as the [List.length] of a typed data list. /// /// If omitted, [start] defaults to zero and [end] to *elementCount*. /// /// The start and end indices of the range of bytes being viewed must be /// multiples of sixteen.&%, 10;A@8%X==/// The concatenation of this list and [other]. /// /// If [other] is also a [Float64x2List], the result is a new [Float64x2List], /// otherwise the result is a normal growable `List`.?POXc-/// A read-only view of this [Float64x2List]. /// Creates a new list containing the elements between [start] and [end]. /// /// The new list is a `Float64x2List` containing the elements of this /// list at positions greater than or equal to [start] and less than [end] in /// the same order as they occur in this list. /// /// ```dart /// var numbers = Float64x2List.fromList([ /// Float64x2(0, 1), /// Float64x2(1, 2), /// Float64x2(2, 3), /// Float64x2(3, 4), /// Float64x2(4, 5), /// ]); /// print(numbers.sublist(1, 3)); // [Float64x2(1, 2), Float64x2(2, 3)] /// print(numbers.sublist(1, 3).runtimeType); // Float64x2List /// ``` /// /// If [end] is omitted, it defaults to the [length] of this list. /// /// ```dart /// print(numbers.sublist(3)); // [Float64x2(3, 4), Float64x2(4, 5)] /// ``` /// /// The `start` and `end` positions must satisfy the relations /// 0 ≤ `start` ≤ `end` ≤ `this.length`. /// If `end` is equal to `start`, then the returned list is empty. c/// Four 32-bit floating point values. /// /// Float32x4 stores four 32-bit floating point values in "lanes". /// The lanes are named [x], [y], [z], and [w] respectively. /// /// Single operations can be performed on the multiple values of one or /// more `Float32x4`s, which will perform the corresponding operation /// for each lane of the operands, and provide a new `Float32x4` (or similar /// multi-value) result with the results from each lane. /// /// The `Float32x4` class cannot be extended or implemented. ppy*/// Creates a `Float32x4` containing the 32-bit float values of the arguments. /// /// The created value has [Float32x4.x], [Float32x4.y], [Float32x4.z] /// and [Float32x4.w] values that are the 32-bit floating point values /// created from the [x], [y], [z] and [w] arguments by conversion /// from 64-bit floating point to 32-bit floating point values. /// /// The conversion from 64-bit float to 32-bit float loses significant /// precision, and may become zero or infinite even if the original 64-bit /// floating point value was non-zero and finite.zM߂ /// Creates a `Float32x4` with the same 32-bit float value four times. /// /// The created value has the same [Float32x4.x], [Float32x4.y], [Float32x4.z] /// and [Float32x4.w] value, which is the 32-bit floating point value /// created by converting the 64-bit floating point [value] to a /// 32-bit floating point value. /// /// The conversion from 64-bit float to 32-bit float loses significant /// precision, and may become zero or infinite even if the original 64-bit /// floating point value was non-zero and finite. /// Creates a `Float32x4` with all values being zero. /// /// The created value has the same [Float32x4.x], [Float32x4.y], [Float32x4.z] /// and [Float32x4.w] value, which is the 32-bit floating point zero value.́/// Creates a `Float32x4` with 32-bit float values from the provided bits. /// /// The created value has [Float32x4.x], [Float32x4.y], [Float32x4.z] /// and [Float32x4.w] values, which are the 32-bit floating point values /// of the bit-representations of the corresponding lanes of [bits]. /// /// The conversion is performed using the *platform endianness* for both /// 32-bit integers and 32-bit floating point numbers. _hiviS/// Creates a `Float32x4` with its [x] and [y] lanes set to values from [xy]. /// /// The created value has [Float32x4.x] and [Float32x4.y] values /// which are the conversions of the [Float64x2.x] and [Float64x2.y] lanes /// of [xy] to 32-bit floating point values. /// The [Float32x4.z] and [Float32x4.w] lanes are set to the zero value.w gbbD/// Shuffle mask "xxxx". /// /// Used by [shuffle] and [shuffleMix].irgD/// Shuffle mask "xxxy". /// /// Used by [shuffle] and [shuffleMix].g::D/// Shuffle mask "xxxz". /// /// Used by [shuffle] and [shuffleMix].AJgææD/// Shuffle mask "xxxw". /// /// Used by [shuffle] and [shuffleMix].íögD/// Shuffle mask "xxyx". /// /// Used by [shuffle] and [shuffleMix]."g~~D/// Shuffle mask "xxyy". /// /// Used by [shuffle] and [shuffleMix].ąĎgD/// Shuffle mask "xxyz". /// /// Used by [shuffle] and [shuffleMix].gVVD/// Shuffle mask "xxyw". /// /// Used by [shuffle] and [shuffleMix].]fgD/// Shuffle mask "xxzx". /// /// Used by [shuffle] and [shuffleMix].g..D/// Shuffle mask "xxzy". /// /// Used by [shuffle] and [shuffleMix].5>gƚƚD/// Shuffle mask "xxzz". /// /// Used by [shuffle] and [shuffleMix].ơƪgD/// Shuffle mask "xxzw". /// /// Used by [shuffle] and [shuffleMix]. grrD/// Shuffle mask "xxwx". /// /// Used by [shuffle] and [shuffleMix].yǂgD/// Shuffle mask "xxwy". /// /// Used by [shuffle] and [shuffleMix].gJJD/// Shuffle mask "xxwz". /// /// Used by [shuffle] and [shuffleMix].QZgȶȶD/// Shuffle mask "xxww". /// /// Used by [shuffle] and [shuffleMix].Ƚg""D/// Shuffle mask "xyxx". /// /// Used by [shuffle] and [shuffleMix].)2gɎɎD/// Shuffle mask "xyxy". /// /// Used by [shuffle] and [shuffleMix].ɕɞgD/// Shuffle mask "xyxz". /// /// Used by [shuffle] and [shuffleMix]. gffD/// Shuffle mask "xyxw". /// /// Used by [shuffle] and [shuffleMix].mvgD/// Shuffle mask "xyyx". /// /// Used by [shuffle] and [shuffleMix].g>>D/// Shuffle mask "xyyy". /// /// Used by [shuffle] and [shuffleMix].ENg˪˪D/// Shuffle mask "xyyz". /// /// Used by [shuffle] and [shuffleMix].˱˺gD/// Shuffle mask "xyyw". /// /// Used by [shuffle] and [shuffleMix].&ĝ̂D/// Shuffle mask "xyzx". /// /// Used by [shuffle] and [shuffleMix].̉̒gD/// Shuffle mask "xyzy". /// /// Used by [shuffle] and [shuffleMix].gZZD/// Shuffle mask "xyzz". /// /// Used by [shuffle] and [shuffleMix].ajgD/// Shuffle mask "xyzw". /// /// Used by [shuffle] and [shuffleMix].g22D/// Shuffle mask "xywx". /// /// Used by [shuffle] and [shuffleMix].9BgΞΞD/// Shuffle mask "xywy". /// /// Used by [shuffle] and [shuffleMix].Υήg  D/// Shuffle mask "xywz". /// /// Used by [shuffle] and [shuffleMix].gvvD/// Shuffle mask "xyww". /// /// Used by [shuffle] and [shuffleMix].}φgD/// Shuffle mask "xzxx". /// /// Used by [shuffle] and [shuffleMix].gNND/// Shuffle mask "xzxy". /// /// Used by [shuffle] and [shuffleMix].U^gккD/// Shuffle mask "xzxz". /// /// Used by [shuffle] and [shuffleMix].g&&D/// Shuffle mask "xzxw". /// /// Used by [shuffle] and [shuffleMix].-6gђђD/// Shuffle mask "xzyx". /// /// Used by [shuffle] and [shuffleMix].љѢgD/// Shuffle mask "xzyy". /// /// Used by [shuffle] and [shuffleMix].gjjD/// Shuffle mask "xzyz". /// /// Used by [shuffle] and [shuffleMix].qzgD/// Shuffle mask "xzyw". /// /// Used by [shuffle] and [shuffleMix].gBBD/// Shuffle mask "xzzx". /// /// Used by [shuffle] and [shuffleMix].IRgӮӮD/// Shuffle mask "xzzy". /// /// Used by [shuffle] and [shuffleMix].ӵӾgD/// Shuffle mask "xzzz". /// /// Used by [shuffle] and [shuffleMix].!*gԆԆD/// Shuffle mask "xzzw". /// /// Used by [shuffle] and [shuffleMix].ԍԖgD/// Shuffle mask "xzwx". /// /// Used by [shuffle] and [shuffleMix].g^^D/// Shuffle mask "xzwy". /// /// Used by [shuffle] and [shuffleMix].engD/// Shuffle mask "xzwz". /// /// Used by [shuffle] and [shuffleMix].g66D/// Shuffle mask "xzww". /// /// Used by [shuffle] and [shuffleMix].=Fg֢֢D/// Shuffle mask "xwxx". /// /// Used by [shuffle] and [shuffleMix].ֲ֩gD/// Shuffle mask "xwxy". /// /// Used by [shuffle] and [shuffleMix].gzzD/// Shuffle mask "xwxz". /// /// Used by [shuffle] and [shuffleMix].ׁ׊gD/// Shuffle mask "xwxw". /// /// Used by [shuffle] and [shuffleMix].gRRD/// Shuffle mask "xwyx". /// /// Used by [shuffle] and [shuffleMix].YbgؾؾD/// Shuffle mask "xwyy". /// /// Used by [shuffle] and [shuffleMix].g**D/// Shuffle mask "xwyz". /// /// Used by [shuffle] and [shuffleMix].1:gٖٖD/// Shuffle mask "xwyw". /// /// Used by [shuffle] and [shuffleMix].ٝ٦gD/// Shuffle mask "xwzx". /// /// Used by [shuffle] and [shuffleMix]. gnnD/// Shuffle mask "xwzy". /// /// Used by [shuffle] and [shuffleMix].u~gD/// Shuffle mask "xwzz". /// /// Used by [shuffle] and [shuffleMix].gFFD/// Shuffle mask "xwzw". /// /// Used by [shuffle] and [shuffleMix].MVg۲۲D/// Shuffle mask "xwwx". /// /// Used by [shuffle] and [shuffleMix].۹gD/// Shuffle mask "xwwy". /// /// Used by [shuffle] and [shuffleMix].%.g܊܊D/// Shuffle mask "xwwz". /// /// Used by [shuffle] and [shuffleMix].ܑܚgD/// Shuffle mask "xwww". /// /// Used by [shuffle] and [shuffleMix].gbbD/// Shuffle mask "yxxx". /// /// Used by [shuffle] and [shuffleMix].irgD/// Shuffle mask "yxxy". /// /// Used by [shuffle] and [shuffleMix].g::D/// Shuffle mask "yxxz". /// /// Used by [shuffle] and [shuffleMix].AJgަަD/// Shuffle mask "yxxw". /// /// Used by [shuffle] and [shuffleMix].ޭ޶gD/// Shuffle mask "yxyx". /// /// Used by [shuffle] and [shuffleMix]."g~~D/// Shuffle mask "yxyy". /// /// Used by [shuffle] and [shuffleMix].߅ߎgD/// Shuffle mask "yxyz". /// /// Used by [shuffle] and [shuffleMix].gVVD/// Shuffle mask "yxyw". /// /// Used by [shuffle] and [shuffleMix].]fgD/// Shuffle mask "yxzx". /// /// Used by [shuffle] and [shuffleMix].g..D/// Shuffle mask "yxzy". /// /// Used by [shuffle] and [shuffleMix].5>gD/// Shuffle mask "yxzz". /// /// Used by [shuffle] and [shuffleMix].gD/// Shuffle mask "yxzw". /// /// Used by [shuffle] and [shuffleMix]. grrD/// Shuffle mask "yxwx". /// /// Used by [shuffle] and [shuffleMix].ygD/// Shuffle mask "yxwy". /// /// Used by [shuffle] and [shuffleMix].gJJD/// Shuffle mask "yxwz". /// /// Used by [shuffle] and [shuffleMix].QZgD/// Shuffle mask "yxww". /// /// Used by [shuffle] and [shuffleMix].g""D/// Shuffle mask "yyxx". /// /// Used by [shuffle] and [shuffleMix].)2gD/// Shuffle mask "yyxy". /// /// Used by [shuffle] and [shuffleMix].gD/// Shuffle mask "yyxz". /// /// Used by [shuffle] and [shuffleMix]. gffD/// Shuffle mask "yyxw". /// /// Used by [shuffle] and [shuffleMix].mvgD/// Shuffle mask "yyyx". /// /// Used by [shuffle] and [shuffleMix].g>>D/// Shuffle mask "yyyy". /// /// Used by [shuffle] and [shuffleMix].ENgD/// Shuffle mask "yyyz". /// /// Used by [shuffle] and [shuffleMix].gD/// Shuffle mask "yyyw". /// /// Used by [shuffle] and [shuffleMix].&gD/// Shuffle mask "yyzx". /// /// Used by [shuffle] and [shuffleMix].gD/// Shuffle mask "yyzy". /// /// Used by [shuffle] and [shuffleMix].gZZD/// Shuffle mask "yyzz". /// /// Used by [shuffle] and [shuffleMix].ajgD/// Shuffle mask "yyzw". /// /// Used by [shuffle] and [shuffleMix].g22D/// Shuffle mask "yywx". /// /// Used by [shuffle] and [shuffleMix].9BgD/// Shuffle mask "yywy". /// /// Used by [shuffle] and [shuffleMix].g  D/// Shuffle mask "yywz". /// /// Used by [shuffle] and [shuffleMix].gvvD/// Shuffle mask "yyww". /// /// Used by [shuffle] and [shuffleMix].}gD/// Shuffle mask "yzxx". /// /// Used by [shuffle] and [shuffleMix].gNND/// Shuffle mask "yzxy". /// /// Used by [shuffle] and [shuffleMix].U^gD/// Shuffle mask "yzxz". /// /// Used by [shuffle] and [shuffleMix].g&&D/// Shuffle mask "yzxw". /// /// Used by [shuffle] and [shuffleMix].-6gD/// Shuffle mask "yzyx". /// /// Used by [shuffle] and [shuffleMix].gD/// Shuffle mask "yzyy". /// /// Used by [shuffle] and [shuffleMix].gjjD/// Shuffle mask "yzyz". /// /// Used by [shuffle] and [shuffleMix].qzgD/// Shuffle mask "yzyw". /// /// Used by [shuffle] and [shuffleMix].gBBD/// Shuffle mask "yzzx". /// /// Used by [shuffle] and [shuffleMix].IRgD/// Shuffle mask "yzzy". /// /// Used by [shuffle] and [shuffleMix].gD/// Shuffle mask "yzzz". /// /// Used by [shuffle] and [shuffleMix].!*gD/// Shuffle mask "yzzw". /// /// Used by [shuffle] and [shuffleMix].gD/// Shuffle mask "yzwx". /// /// Used by [shuffle] and [shuffleMix].g^^D/// Shuffle mask "yzwy". /// /// Used by [shuffle] and [shuffleMix].engD/// Shuffle mask "yzwz". /// /// Used by [shuffle] and [shuffleMix].g66D/// Shuffle mask "yzww". /// /// Used by [shuffle] and [shuffleMix].=FgD/// Shuffle mask "ywxx". /// /// Used by [shuffle] and [shuffleMix].gD/// Shuffle mask "ywxy". /// /// Used by [shuffle] and [shuffleMix].gzzD/// Shuffle mask "ywxz". /// /// Used by [shuffle] and [shuffleMix].gD/// Shuffle mask "ywxw". /// /// Used by [shuffle] and [shuffleMix].gRRD/// Shuffle mask "ywyx". /// /// Used by [shuffle] and [shuffleMix].YbgD/// Shuffle mask "ywyy". /// /// Used by [shuffle] and [shuffleMix].g**D/// Shuffle mask "ywyz". /// /// Used by [shuffle] and [shuffleMix].1:gD/// Shuffle mask "ywyw". /// /// Used by [shuffle] and [shuffleMix].gD/// Shuffle mask "ywzx". /// /// Used by [shuffle] and [shuffleMix]. gnnD/// Shuffle mask "ywzy". /// /// Used by [shuffle] and [shuffleMix].u~gD/// Shuffle mask "ywzz". /// /// Used by [shuffle] and [shuffleMix].gFFD/// Shuffle mask "ywzw". /// /// Used by [shuffle] and [shuffleMix].MVgD/// Shuffle mask "ywwx". /// /// Used by [shuffle] and [shuffleMix].gD/// Shuffle mask "ywwy". /// /// Used by [shuffle] and [shuffleMix].%.gD/// Shuffle mask "ywwz". /// /// Used by [shuffle] and [shuffleMix].gD/// Shuffle mask "ywww". /// /// Used by [shuffle] and [shuffleMix].gbbD/// Shuffle mask "zxxx". /// /// Used by [shuffle] and [shuffleMix].irgD/// Shuffle mask "zxxy". /// /// Used by [shuffle] and [shuffleMix].g::D/// Shuffle mask "zxxz". /// /// Used by [shuffle] and [shuffleMix].AJgD/// Shuffle mask "zxxw". /// /// Used by [shuffle] and [shuffleMix].gD/// Shuffle mask "zxyx". /// /// Used by [shuffle] and [shuffleMix]."g~~D/// Shuffle mask "zxyy". /// /// Used by [shuffle] and [shuffleMix].gD/// Shuffle mask "zxyz". /// /// Used by [shuffle] and [shuffleMix].gVVD/// Shuffle mask "zxyw". /// /// Used by [shuffle] and [shuffleMix].]fgD/// Shuffle mask "zxzx". /// /// Used by [shuffle] and [shuffleMix].g..D/// Shuffle mask "zxzy". /// /// Used by [shuffle] and [shuffleMix].5>gD/// Shuffle mask "zxzz". /// /// Used by [shuffle] and [shuffleMix].gD/// Shuffle mask "zxzw". /// /// Used by [shuffle] and [shuffleMix]. grrD/// Shuffle mask "zxwx". /// /// Used by [shuffle] and [shuffleMix].ygD/// Shuffle mask "zxwy". /// /// Used by [shuffle] and [shuffleMix].gJJD/// Shuffle mask "zxwz". /// /// Used by [shuffle] and [shuffleMix].QZgD/// Shuffle mask "zxww". /// /// Used by [shuffle] and [shuffleMix].g""D/// Shuffle mask "zyxx". /// /// Used by [shuffle] and [shuffleMix].)2gD/// Shuffle mask "zyxy". /// /// Used by [shuffle] and [shuffleMix].gD/// Shuffle mask "zyxz". /// /// Used by [shuffle] and [shuffleMix]. gffD/// Shuffle mask "zyxw". /// /// Used by [shuffle] and [shuffleMix].mvgD/// Shuffle mask "zyyx". /// /// Used by [shuffle] and [shuffleMix].g>>D/// Shuffle mask "zyyy". /// /// Used by [shuffle] and [shuffleMix].ENgD/// Shuffle mask "zyyz". /// /// Used by [shuffle] and [shuffleMix].gD/// Shuffle mask "zyyw". /// /// Used by [shuffle] and [shuffleMix].&gD/// Shuffle mask "zyzx". /// /// Used by [shuffle] and [shuffleMix].gD/// Shuffle mask "zyzy". /// /// Used by [shuffle] and [shuffleMix].gZZD/// Shuffle mask "zyzz". /// /// Used by [shuffle] and [shuffleMix].ajgD/// Shuffle mask "zyzw". /// /// Used by [shuffle] and [shuffleMix].g22D/// Shuffle mask "zywx". /// /// Used by [shuffle] and [shuffleMix].9BgD/// Shuffle mask "zywy". /// /// Used by [shuffle] and [shuffleMix].g  D/// Shuffle mask "zywz". /// /// Used by [shuffle] and [shuffleMix].gvvD/// Shuffle mask "zyww". /// /// Used by [shuffle] and [shuffleMix].}gD/// Shuffle mask "zzxx". /// /// Used by [shuffle] and [shuffleMix].gNND/// Shuffle mask "zzxy". /// /// Used by [shuffle] and [shuffleMix].U^gD/// Shuffle mask "zzxz". /// /// Used by [shuffle] and [shuffleMix].g&&D/// Shuffle mask "zzxw". /// /// Used by [shuffle] and [shuffleMix].-6gD/// Shuffle mask "zzyx". /// /// Used by [shuffle] and [shuffleMix].gD/// Shuffle mask "zzyy". /// /// Used by [shuffle] and [shuffleMix].gjjD/// Shuffle mask "zzyz". /// /// Used by [shuffle] and [shuffleMix].qzgD/// Shuffle mask "zzyw". /// /// Used by [shuffle] and [shuffleMix].g B BD/// Shuffle mask "zzzx". /// /// Used by [shuffle] and [shuffleMix]. I Rg  D/// Shuffle mask "zzzy". /// /// Used by [shuffle] and [shuffleMix].  g  D/// Shuffle mask "zzzz". /// /// Used by [shuffle] and [shuffleMix]. ! *g  D/// Shuffle mask "zzzw". /// /// Used by [shuffle] and [shuffleMix].  g  D/// Shuffle mask "zzwx". /// /// Used by [shuffle] and [shuffleMix].  g ^ ^D/// Shuffle mask "zzwy". /// /// Used by [shuffle] and [shuffleMix]. e ng  D/// Shuffle mask "zzwz". /// /// Used by [shuffle] and [shuffleMix].  g 6 6D/// Shuffle mask "zzww". /// /// Used by [shuffle] and [shuffleMix]. = Fg  D/// Shuffle mask "zwxx". /// /// Used by [shuffle] and [shuffleMix].  g  D/// Shuffle mask "zwxy". /// /// Used by [shuffle] and [shuffleMix].  g z zD/// Shuffle mask "zwxz". /// /// Used by [shuffle] and [shuffleMix].  g  D/// Shuffle mask "zwxw". /// /// Used by [shuffle] and [shuffleMix].  gRRD/// Shuffle mask "zwyx". /// /// Used by [shuffle] and [shuffleMix].YbgD/// Shuffle mask "zwyy". /// /// Used by [shuffle] and [shuffleMix].g**D/// Shuffle mask "zwyz". /// /// Used by [shuffle] and [shuffleMix].1:gD/// Shuffle mask "zwyw". /// /// Used by [shuffle] and [shuffleMix].gD/// Shuffle mask "zwzx". /// /// Used by [shuffle] and [shuffleMix]. gnnD/// Shuffle mask "zwzy". /// /// Used by [shuffle] and [shuffleMix].u~gD/// Shuffle mask "zwzz". /// /// Used by [shuffle] and [shuffleMix].gFFD/// Shuffle mask "zwzw". /// /// Used by [shuffle] and [shuffleMix].MVgD/// Shuffle mask "zwwx". /// /// Used by [shuffle] and [shuffleMix].gD/// Shuffle mask "zwwy". /// /// Used by [shuffle] and [shuffleMix].%.gD/// Shuffle mask "zwwz". /// /// Used by [shuffle] and [shuffleMix].gD/// Shuffle mask "zwww". /// /// Used by [shuffle] and [shuffleMix].gbbD/// Shuffle mask "wxxx". /// /// Used by [shuffle] and [shuffleMix].irgD/// Shuffle mask "wxxy". /// /// Used by [shuffle] and [shuffleMix].g::D/// Shuffle mask "wxxz". /// /// Used by [shuffle] and [shuffleMix].AJgD/// Shuffle mask "wxxw". /// /// Used by [shuffle] and [shuffleMix].gD/// Shuffle mask "wxyx". /// /// Used by [shuffle] and [shuffleMix]."g~~D/// Shuffle mask "wxyy". /// /// Used by [shuffle] and [shuffleMix].gD/// Shuffle mask "wxyz". /// /// Used by [shuffle] and [shuffleMix].gVVD/// Shuffle mask "wxyw". /// /// Used by [shuffle] and [shuffleMix].]fgD/// Shuffle mask "wxzx". /// /// Used by [shuffle] and [shuffleMix].g..D/// Shuffle mask "wxzy". /// /// Used by [shuffle] and [shuffleMix].5>gD/// Shuffle mask "wxzz". /// /// Used by [shuffle] and [shuffleMix].gD/// Shuffle mask "wxzw". /// /// Used by [shuffle] and [shuffleMix]. grrD/// Shuffle mask "wxwx". /// /// Used by [shuffle] and [shuffleMix].ygD/// Shuffle mask "wxwy". /// /// Used by [shuffle] and [shuffleMix].gJJD/// Shuffle mask "wxwz". /// /// Used by [shuffle] and [shuffleMix].QZgD/// Shuffle mask "wxww". /// /// Used by [shuffle] and [shuffleMix].g""D/// Shuffle mask "wyxx". /// /// Used by [shuffle] and [shuffleMix].)2gD/// Shuffle mask "wyxy". /// /// Used by [shuffle] and [shuffleMix].gD/// Shuffle mask "wyxz". /// /// Used by [shuffle] and [shuffleMix]. gffD/// Shuffle mask "wyxw". /// /// Used by [shuffle] and [shuffleMix].mvgD/// Shuffle mask "wyyx". /// /// Used by [shuffle] and [shuffleMix].g>>D/// Shuffle mask "wyyy". /// /// Used by [shuffle] and [shuffleMix].ENgD/// Shuffle mask "wyyz". /// /// Used by [shuffle] and [shuffleMix].gD/// Shuffle mask "wyyw". /// /// Used by [shuffle] and [shuffleMix].&gD/// Shuffle mask "wyzx". /// /// Used by [shuffle] and [shuffleMix].gD/// Shuffle mask "wyzy". /// /// Used by [shuffle] and [shuffleMix].gZZD/// Shuffle mask "wyzz". /// /// Used by [shuffle] and [shuffleMix].ajgD/// Shuffle mask "wyzw". /// /// Used by [shuffle] and [shuffleMix].g22D/// Shuffle mask "wywx". /// /// Used by [shuffle] and [shuffleMix].9BgD/// Shuffle mask "wywy". /// /// Used by [shuffle] and [shuffleMix].g  D/// Shuffle mask "wywz". /// /// Used by [shuffle] and [shuffleMix].  g v vD/// Shuffle mask "wyww". /// /// Used by [shuffle] and [shuffleMix]. } g  D/// Shuffle mask "wzxx". /// /// Used by [shuffle] and [shuffleMix].  g!N!ND/// Shuffle mask "wzxy". /// /// Used by [shuffle] and [shuffleMix].!U!^g!!D/// Shuffle mask "wzxz". /// /// Used by [shuffle] and [shuffleMix].!!g"&"&D/// Shuffle mask "wzxw". /// /// Used by [shuffle] and [shuffleMix]."-"6g""D/// Shuffle mask "wzyx". /// /// Used by [shuffle] and [shuffleMix].""g""D/// Shuffle mask "wzyy". /// /// Used by [shuffle] and [shuffleMix].##g#j#jD/// Shuffle mask "wzyz". /// /// Used by [shuffle] and [shuffleMix].#q#zg##D/// Shuffle mask "wzyw". /// /// Used by [shuffle] and [shuffleMix].##g$B$BD/// Shuffle mask "wzzx". /// /// Used by [shuffle] and [shuffleMix].$I$Rg$$D/// Shuffle mask "wzzy". /// /// Used by [shuffle] and [shuffleMix].$$g%%D/// Shuffle mask "wzzz". /// /// Used by [shuffle] and [shuffleMix].%!%*g%%D/// Shuffle mask "wzzw". /// /// Used by [shuffle] and [shuffleMix].%%g%%D/// Shuffle mask "wzwx". /// /// Used by [shuffle] and [shuffleMix].%&g&^&^D/// Shuffle mask "wzwy". /// /// Used by [shuffle] and [shuffleMix].&e&ng&&D/// Shuffle mask "wzwz". /// /// Used by [shuffle] and [shuffleMix].&&g'6'6D/// Shuffle mask "wzww". /// /// Used by [shuffle] and [shuffleMix].'='Fg''D/// Shuffle mask "wwxx". /// /// Used by [shuffle] and [shuffleMix].''g((D/// Shuffle mask "wwxy". /// /// Used by [shuffle] and [shuffleMix].((g(z(zD/// Shuffle mask "wwxz". /// /// Used by [shuffle] and [shuffleMix].((g((D/// Shuffle mask "wwxw". /// /// Used by [shuffle] and [shuffleMix].((g)R)RD/// Shuffle mask "wwyx". /// /// Used by [shuffle] and [shuffleMix].)Y)bg))D/// Shuffle mask "wwyy". /// /// Used by [shuffle] and [shuffleMix].))g****D/// Shuffle mask "wwyz". /// /// Used by [shuffle] and [shuffleMix].*1*:g**D/// Shuffle mask "wwyw". /// /// Used by [shuffle] and [shuffleMix].**g++D/// Shuffle mask "wwzx". /// /// Used by [shuffle] and [shuffleMix].+ +g+n+nD/// Shuffle mask "wwzy". /// /// Used by [shuffle] and [shuffleMix].+u+~g++D/// Shuffle mask "wwzz". /// /// Used by [shuffle] and [shuffleMix].++g,F,FD/// Shuffle mask "wwzw". /// /// Used by [shuffle] and [shuffleMix].,M,Vg,,D/// Shuffle mask "wwwx". /// /// Used by [shuffle] and [shuffleMix].,,g--D/// Shuffle mask "wwwy". /// /// Used by [shuffle] and [shuffleMix].-%-.g--D/// Shuffle mask "wwwz". /// /// Used by [shuffle] and [shuffleMix].--g--D/// Shuffle mask "wwww". /// /// Used by [shuffle] and [shuffleMix].-./// The value of the "x" lane..///// The value of the "y" lane.5.aa/// The value of the "z" lane.g./// The value of the "w" lane.8ȁ/// The sign bits of each lane as single bits. /// /// The sign bits of each lane's 32-bit floating point value /// are stored in the low four bits of this value: /// - The [x] lane in bit 0. /// - The [y] lane in bit 1. /// - The [z] lane in bit 2. /// - The [w] lane in bit 3.SS/// Lane-wise addition. /// /// Adds the value of each lane of this value /// to the value of the corresponding lane of [other]. /// /// Returns the result for each lane.U`_j}/// Lane-wise negation. /// /// Returns a result where each lane is the negation of the corresponding /// lane of this value. ߀/// Lane-wise subtraction. /// /// Subtracts the value of each lane of [other] /// from the value of the corresponding lane of this value. /// /// Returns the result for each lane.΀/// Lane-wise multiplication. /// /// Multiplies the value of each lane of this value /// with the value of the corresponding lane of [other]. /// /// Returns the result for each lane./// Lane-wise division. /// /// Divides the value of each lane of this value /// with the value of the corresponding lane of [other]. /// /// Returns the result for each lane.˃/// Lane-wise less-than comparison. /// /// Compares the 32-bit floating point value of each lane of this /// to the value of the corresponding lane of [other], /// using 32-bit floating point comparison. /// _For floating point comparisons, a comparison with a NaN value is /// always false, and -0.0 (negative zero) is considered equal to 0.0 /// (positive zero), and not less strictly than it._ /// The result for a lane is a 32-bit signed integer which is -1 /// (all bits set) if the value from this object is *less than* /// the value from [other], and the result is 0 (all bits cleared) if not, /// including if either value is a NaN value. /// /// Returns four values that are always either 0 or -1.у΂/// Lane-wise less-than-or-equal comparison. /// /// Compares the 32-bit floating point value of each lane of this /// to the value of the corresponding lane of [other], /// using 32-bit floating point comparison. /// _For floating point comparisons, a comparison with a NaN value is /// always false, and -0.0 (negative zero) is considered equal to 0.0 /// (positive zero), and not less strictly than it._ /// The result for a lane is a 32-bit signed integer which is -1 /// (all bits set) if the value from this object is *less than or equal to* /// the value from [other], and the result is 0 (all bits cleared) if not, /// including if either value is a NaN value. /// /// Returns four values that are always either 0 or -1. /// Lane-wise greater-than comparison. /// /// Compares the 32-bit floating point value of each lane of this /// to the value of the corresponding lane of [other], /// using 32-bit floating point comparison. /// _For floating point comparisons, a comparison with a NaN value is /// always false, and -0.0 (negative zero) is considered equal to 0.0 /// (positive zero), and not less strictly than it._ /// The result for a lane is a 32-bit signed integer which is -1 /// (all bits set) if the value from this object is *greater than* /// the value from [other], and the result is 0 (all bits cleared) if not, /// including if either value is a NaN value. /// /// Returns four values that are always either 0 or -1.'/// Lane-wise greater-than-or-equal comparison. /// /// Compares the 32-bit floating point value of each lane of this /// to the value of the corresponding lane of [other], /// using 32-bit floating point comparison. /// _For floating point comparisons, a comparison with a NaN value is /// always false, and -0.0 (negative zero) is considered equal to 0.0 /// (positive zero), and not less strictly than it._ /// The result for a lane is a 32-bit signed integer which is -1 /// (all bits set) if the value from this object is *greater than or equal to* /// the value from [other], and the result is 0 (all bits cleared) if not, /// including if either value is a NaN value. /// /// Returns four values that are always either 0 or -1.#"-/// Lane-wise equals comparison. /// /// Compares the 32-bit floating point value of each lane of this /// to the value of the corresponding lane of [other], /// using 32-bit floating point comparison. /// _For floating point comparisons, a comparison with a NaN value is /// always false, and -0.0 (negative zero) is considered equal to 0.0 /// (positive zero), and not less strictly than it._ /// The result for a lane is a 32-bit signed integer which is -1 /// (all bits set) if the value from this object is *equal to* /// the value from [other], and the result is 0 (all bits cleared) if not, /// including if either value is a NaN value. /// /// Returns four values that are always either 0 or -1."!,/// Lane-wise not-equals comparison. /// /// Compares the 32-bit floating point value of each lane of this /// to the value of the corresponding lane of [other], /// using 32-bit floating point comparison. /// _For floating point comparisons, a comparison with a NaN value is /// always false, and -0.0 (negative zero) is considered equal to 0.0 /// (positive zero), and not less strictly than it._ /// The result for a lane is a 32-bit signed integer which is -1 /// (all bits set) if the value from this object is *not equal to* /// the value from [other], and the result is 0 (all bits cleared) if not, /// including if either value is a NaN value. /// /// Returns four values that are always either 0 or -1.!,+6c./// Lane-wise multiplication by [scale]. /// /// Returns a result where each lane is the result of multiplying the /// corresponding lane of this value with [scale]. /// This can happen either by converting the lane value to a 64-bit /// floating point value, multiplying it with [scale] and converting /// the result back to a 32-bit floating point value, /// or by converting [scale] to a 32-bit floating point value /// and performing a 32-bit floating point multiplication. /// /// In the latter case it is equivalent to `thisValue * Float32x4.splat(s)`. /// Lane-wise conversion to absolute value. /// /// Converts each lane's value to a non-negative value /// by negating the value if it is negative, /// and keeping the original value if it is not negative. /// /// Returns the result for each lane./// Lane-wise clamp to a range. /// /// Clamps the value of each lane to a minimum value /// of the corresponding lane of [lowerLimit] /// and a maximum value of the corresponding lane of [upperLimit]. /// If the original value is lower than the minimum value, the result is /// the minimum value, and if original value is greater than the maximum /// value, the result is the maximum value. /// The result is unspecified if the maximum value is lower than the minimum /// value, or if any of the three values is a NaN value, other than that /// the result will be one of those three values, or possibly a different /// NaN value if any value is a NaN value. /// /// Returns the result for each lane..22f/// Shuffle the lane values based on the [mask]. /// /// The [mask] must be one of the 256 shuffle masks from [xxxx] to [wwww]. /// /// Creates a new [Float32x4] whose lane values are taken from the /// lanes of this value based on the lanes of the shuffle mask, /// with the result's [x] lane being taken from the lane of the first /// letter of the shuffle mask's name, the [y] lane from the second letter, /// [z] lane from the third letter and [w] lane from the fourth letter. /// /// For example, the shuffle mask [wxyz] creates a new `Float32x4` /// whose [x] lane is the [w] lane of this value, because the first letter /// of the shuffle mask's name, `wxyz` is "w". Then the `y`, `z` and `w` /// lanes of the result are the values of the `x`, `y` and `z` lanes /// of this value. /// /// The [xyzw] "identity shuffle" mask gives a result with the same lanes /// as the original. /// /// Some masks preserve the values of all lanes, but may permute them. /// Other masks duplicates some lanes and discards the values of others. /// /// For example, doing `v1.shuffle(yyyy)` is equivalent to /// `Float32x4.splat(v1.y)`.22225c5c/// Mixes lanes chosen from two [Float32x4] values using a [mask]. /// /// Creates a new [Float32x4] where the [x] and [y] lanes are chosen /// from the lanes of this value selected by the first two letters of the /// [mask]'s name, and the [z] and [w] lanes are the lanes of [other] /// selected by the last two letters of the `mask`'s name. /// /// For example, `v1.shuffleMix(v2, Float32x4.xyzw)` is equivalent /// to `Float32x4(v1.x, v1.y, v2.z, v2.w)`. /// /// If [other] is the same value as this `Float32x4`, this function /// is the same as [shuffle]. That is, doing /// `v1.shuffleMix(v1, mask)` is equivalent to `v1.shuffle(mask)`.5n5y5x5555:66/// This value, but with the value of the [Float32x4.x] lane set to [x]. /// /// Returns a new [Float32x4] with the same values for the [y], [z] /// and [w] lanes as this value, and with a [Float32x4.x] lane /// having the value [x] converted to a 32-bit floating point number.6666ˁ:77/// This value, but with the value of the [Float32x4.y] lane set to [y]. /// /// Returns a new [Float32x4] with the same values for the [x], [z] /// and [w] lanes as this value, and with a [Float32x4.y] lane /// having the value [y] converted to a 32-bit floating point number.7888 :9393/// This value, but with the value of the [Float32x4.z] lane set to [z]. /// /// Returns a new [Float32x4] with the same values for the [x], [y] /// and [w] lanes as this value, and with a [Float32x4.z] lane /// having the value [z] converted to a 32-bit floating point number.999A9@9G::q:q/// This value, but with the value of the [Float32x4.w] lane set to [w]. /// /// Returns a new [Float32x4] with the same values for the [x], [y] /// and [z] lanes as this value, and with a [Float32x4.w] lane /// having the value [w] converted to a 32-bit floating point number.:w::~:'<>Ł/// Lane-wise maximum. /// /// For each lane select the greater of the lane value of this and [other]. /// /// The result is the greater of the two lane values if either is greater. /// The result is unspecified if either lane contains a NaN value or /// if the values are -0.0 and 0.0, so that neither value is smaller /// or greater than the other. /// Different platforms may give different results in those cases, /// but always one of the lane values. /// /// Returns the result for each lane.>>>>ނ5A A /// Lane-wise square root. /// /// For each lane compute the 32-bit floating point square root of the /// lane's value. /// /// The result for a lane is a NaN value if the original value /// is less than zero or if it is a NaN value. /// The result for a negative zero, -0.0, is the same value again. /// The result for positive infinity is positive infinity. /// Otherwise the result is a positive value which approximates /// the mathematical square root of the original value. /// /// Returns the result for each lane.ACC/// Lane-wise reciprocal. /// /// For each lane compute the result of dividing 1.0 by the lane's value. /// /// If the value is a NaN value, so is the result. /// If the value is infinite, the result is a zero value with the same sign. /// If the value is zero, the result is infinite with the same sign. /// Otherwise the result is an approximation of the mathematical result /// of dividing 1 by the (finite, non-zero) value of the lane. /// /// Returns the result for each lane.C*0FIFI/// Lane-wise approximation of reciprocal square root. /// /// Approximates the same result as [reciprocal] followed by [sqrt], /// or [sqrt] followed by [reciprocal], /// but may be more precise and/or efficient due to computing the result /// directly, rather than not creating a an intermediate result, /// and possibly by working entirely at a reduced precision. /// /// The result can differ between platforms due to differences in /// approximation and precision, and for values where the order of [sqrt] and /// [reciprocal] makes a difference. /// The latter applies specifically to `-0.0` /// where `sqrt(-0.0)` is defined to be -0.0, /// and `reciprocal` of that is -Infinity. /// In the opposite order it computes `sqrt` of -Infinity which is NaN.F^FF/// Int32x4 and operations. /// /// Int32x4 stores 4 32-bit bit-masks in "lanes". /// The lanes are "x", "y", "z", and "w" respectively.G5GGG G!G&G%G(G-G,G/G4G3G6G;G:G@>GQGXGYG]GYG^GdGcGfGlGkGnGtGsGvG|G{G8GGGGGG GGJLJJ-/// Mask passed to [shuffle] or [shuffleMix].JJK K KKK*K*K1K9KJKJKQKYKjKjKqKyKKKKKKKKKKKKKKKKL L LLL*L*L1L9LJLJLQLYLjLjLqLyLLLLLLLLLLLLLLLLM M MMM*M*M1M9MJMJMQMYMjMjMqMyMMMMMMMMMMMMMMMMN N NNN*N*N1N9NJNJNQNYNjNjNqNyNNNNNNNNNNNNNNNNO O OOO*O*O1O9OJOJOQOYOjOjOqOyOOOOOOOOOOOOOOOOP P PPP*P*P1P9PJPJPQPYPjPjPqPyPPPPPPPPPPPPPPPPQ Q QQQ*Q*Q1Q9QJQJQQQYQjQjQqQyQQQQQQQQQQQQQQQQR R RRR*R*R1R9RJRJRQRYRjRjRqRyRRRRRRRRRRRRRRRRS S SSS*S*S1S9SJSJSQSYSjSjSqSySSSSSSSSSSSSSSSST T TTT*T*T1T9TJTJTQTYTjTjTqTyTTTTTTTTTTTTTTTTU U UUU*U*U1U9UJUJUQUYUjUjUqUyUUUUUUUUUUUUUUUUV V VVV*V*V1V9VJVJVQVYVjVjVqVyVVVVVVVVVVVVVVVVW W WWW*W*W1W9WJWJWQWYWjWjWqWyWWWWWWWWWWWWWWWWX X XXX*X*X1X9XJXJXQXYXjXjXqXyXXXXXXXXXXXXXXXXY Y YYY*Y*Y1Y9YJYJYQYYYjYjYqYyYYYYYYYYYYYYYYYYZ Z ZZZ*Z*Z1Z9ZJZJZQZYZjZjZqZyZZZZZZZZZZZZZZZZ[ [ [[[*[*[1[9[J[J[Q[Y[j[j[q[y[[[[[[[[[[[[[[[[\ \ \\\*\*\1\9\J\J\Q\Y\j\j\q\y\\\\\\\\\\\\\\\\] ] ]]]*]*]1]9]J]J]Q]Y]j]j]q]y]]]]]]]]]]]]]]]]^ ^ ^^^*^*^1^9^J^J^Q^Y^j^j^q^y^^^^^^^^^^^^^^^^_ _ ___*_*_1_9_J_J_Q_Y_j_j_q_y________________` ` ```*`*`1`9`J`J`Q`Y`j`j`q`y````````````````a a aaa*a*a1a9aJaJaQaYajajaqayaaaaaaaaaaaaaaaab b bbb*b*b1b9bJbJbQbYbjbjbqbybbbbbbbbbbbbbbbbc c ccc*c*c1c9cJcJcQcYcjcjcqcyccccccccccccccccd d ddd*d*d1d9dJdJdQdYdjdjdqdydddddddddddddddde e eee*e*e1e9eJeJeQeYejejeqeyeeeeeeeeeeeeeeeef f fff*f*f1f9fJfJfQfYfjfjfqfyffffffffffffffffg g ggg*g*g1g9gJgJgQgYgjgjgqgyggggggggggggggggh h hhh*h*h1h9hJhJhQhYhjhjhqhyhhhhhhhhhhhhhhhhi i iii*i*i1i9iJiJiQiYijijiqiyiiiiiiiiiiiiiiiij j jjj*j*j1j9jJjJjQjYjjjjjqjyjjjjjjjjjjj I1IAIA$/// Extract 32-bit mask from x lane.IG1IvIv$/// Extract 32-bit mask from y lane.I|1II$/// Extract 32-bit mask from z lane.I1II$/// Extract 32-bit mask from w lane.I怿JJ/// Extract the top bit from each lane return them in the first 4 bits. /// "x" lane is bit 0. /// "y" lane is bit 1. /// "z" lane is bit 2. /// "w" lane is bit 3.mWn$n$E/// Extracted x value. Returns false for 0, true for any other value.n.WnnE/// Extracted y value. Returns false for 0, true for any other value.nWnnE/// Extracted z value. Returns false for 0, true for any other value.nWo5o5E/// Extracted w value. Returns false for 0, true for any other value.GBGG/// The bit-wise or operator.G GGHCH5H5/// The bit-wise and operator.H7 H@H?HJCH|H|/// The bit-wise xor operator.H~ HHH;HH/// Addition operator.H HHH>HH/// Subtraction operator.H IIjjk2k2M/// Shuffle the lane values. [mask] must be one of the 256 shuffle constants.k:k?k>kHll/// Shuffle the lane values in this [Int32x4] and [other]. The returned /// Int32x4 will have XY lanes from this [Int32x4] and ZW lanes from [other]. /// Uses the same [mask] as [shuffle].l l'l&l-l2l1l;bllJ/// Returns a new [Int32x4] copied from this [Int32x4] with a new x value.llllbllJ/// Returns a new [Int32x4] copied from this [Int32x4] with a new y value.lmmmbm\m\J/// Returns a new [Int32x4] copied from this [Int32x4] with a new z value.mbmgmfmmbmmJ/// Returns a new [Int32x4] copied from this [Int32x4] with a new w value.mmmo?gooJ/// Returns a new [Int32x4] copied from this [Int32x4] with a new x value.oooogooJ/// Returns a new [Int32x4] copied from this [Int32x4] with a new y value.p pppgpjpjJ/// Returns a new [Int32x4] copied from this [Int32x4] with a new z value.ptpzpypgppJ/// Returns a new [Int32x4] copied from this [Int32x4] with a new w value.ppppqqʀ/// Merge [trueValue] and [falseValue] based on this [Int32x4] bit mask: /// Select bit from [trueValue] when bit in this [Int32x4] is on. /// Select bit from [falseValue] when bit in this [Int32x4] is off.qqqqqqrss/// Float64x2 immutable value type and operations. /// /// Float64x2 stores 2 64-bit floating point values in "lanes". /// The lanes are "x" and "y" respectively. /// /// It is a compile-time error for a class to attempt to extend or implement /// `Float64x2`.s(/s9s9sBsCsKsJsMsUsTsZ+skstsuszsus{sss"ssssssasssts(/// Uses the "x" and "y" lanes from [v].t t t v&vv/// Extracted x value.w&w'w'/// Extracted y value.w-www/// Extract the sign bits from each lane return them in the first 2 bits. /// "x" lane is bit 0. /// "y" lane is bit 1. t?t?t?/// Addition operator.tAtLtKtV.tt/// Negate operator.tBtt/// Subtraction operator.ttttEuu/// Multiplication operator.uu u u?uCuC/// Division operator.uEuPuOuZuuu/// Returns a copy of this [Float64x2] each lane being scaled by [s]. /// Equivalent to this * new Float64x2.splat(s)uuuuHv4v45/// The lane-wise absolute value of this [Float64x2].v>vvV/// Lane-wise clamp this [Float64x2] to be in the range /// [lowerLimit]-[upperLimit].vvvvvvwqx!x!R/// Returns a new [Float64x2] copied from this [Float64x2] with a new x /// value.x'x/x.x5qxxR/// Returns a new [Float64x2] copied from this [Float64x2] with a new y /// value.xxxxaxx?/// The lane-wise minimum value in this [Float64x2] or [other].xyyyay[y[?/// The lane-wise maximum value in this [Float64x2] or [other].y_yjyiytFyy2/// The lane-wise square root of this [Float64x2].dart.typed_dataN؀ف PTz EFqri{̓+1lɄυgmc'm׈!'sy҉Z[5KQ;Ao23x~mՎ>ߎ(ZԐZ`NntՒۓ ;f:@{Ôٔߕ/`PciʖЖ1\17rϘՙ%VיFY_ƚ'R&,gŜ˝L͝=PVJڟ۠%`áD{š5HNBУѤX< YntاSݧg}өJi̩Ҫ39gūWX߬(>D *{)]ׯci \԰ATZ±&Q17rӳٴ*X"(uo;5;1npqkӺ/0c|~ĻҼ]޽*J9?̿L{}~@;@@@AAZA^AAB9B}BBBBC C3C4CaCCCDDDDDaDDDEEgEEFFQFUFFFFG GXGbGhGpGtGGH8HzHHHHIIIIkI{IIJJ;JdJeJJJK KOKKKKL0LfLLLM#M]MMMN/N9NiNNNNOO[OOOOOOPP"P#PePkPPQ7Q~QQQRR4R:RRRS SWSSSSSSTTGTjTqTuTvTTTTUU`UvU|UUUVV=V>VVVVWAWGWxWWWXXOXUXXXXYYY]YYYZ ZZDZoZZZ[.[:[@[[[[\'\e\f\\]&],]S]]]^^e^f^^^__M_S__```c```aa+a1abaaabEbbbbcc c:cccdd^ddddde0eeef fTf`fffffg:gygzghh4h:hhhhhiieifiijj j[jljrjjk1k2k|kkkl#ldljllm5m6mymmmnn%nVnnno7o}oooppp8pppqqRqqqrr\r]rrs$s*sssttNttu4ujupuuv@vAvvwww7wwwxxYxxxyyiykylyyyz)z-ztzzz{+{;{t{{{|=|f|g|||}}N}T}}}}~6~<~x~~<rx,2}?/=jt#<Up Pbh ]c&LYd AQrsb@JP+V&*f<PT6_e(LR -hiT5>x LV:z ?CD Y"V\-z;k17BC2Z`n"gm{(m9 :>5^d,hn7D9O,2s7|DRDN7RcjA{SYNT Agt -489l|CF$.4uACD(,p,=w1Oyz0bh TZ6[$KQ*d8Bs&f+/0tzF CI k%2=fmŸ&FOUyé89ąċ QWeŞ ^drƣƭƳdǐǑǹǻǼWȢȦ+AEɒɤ'SYʙʷ,PV˚9uv̵!7z͹[Χhϭ,o}н .]gѭ1Jev}ҴҸҹHӂZ`ԒԘU[գթ Z։ּ֯)Vqװ4Y`deؒآ]٭,Zژڢڨ2<Bۃۮ !IKLܔܥܩ04x=NވB`ߊߋAsyekGl5\b;u IS7w<@A W TZ+1|7DOx8Xag(JK2ciw%+pv1v)-i=X\>jpCgm)P8N+1r.4C7Et~-Ha|_-qw/lr $rAnLqx|}*0u Dr JTZ 89acdHLhy'-m " ( l     F G     3 r     `     ! f  '5t~b*1gkl5 EKV\=cp{ %d DTvw^ GQW2]DUY(i,t/0y_$*o  , b h  !!"!e!k!!"5"z""# ##G#n#|###$;$d$$$$$%%%%K%Q%%&&d&&&&'' 'f''''(B(\((() ))@)G)y))** *)*/*T*******+++b+h++,.,4,B,|,,,,-=-C-Q-----.C.p.q....///3/~///0-0L0P0001:1c1i11112>2b2h2223$3K33334484{44555\555666i667.7q77778$828b8l889979P9k9|9999:: :Q::;;c;i;;;;>4>a>|>>>>??@?e?l?p?q????@ @&@l@@@AAFAxAAAB BB BYBcBiBBCCHCICqCsCtCCCD DWD~DDDE ElEEEEF%F&FpFFFGGAGBGGGGH1HpHHHII^IIIIJJdJJK'K5KvKKKKLL"LhLLLMM!M2M9MqMuMvMMNN@NNOOOPOVOOOPPPaPgPPQQJQpQ}QQQQRR2RqRRRRRSS"S&S'SUSeSSSST"TrTTTTU.UmUwU}UUUVVVV`VVVVW'W)W*WoWWWX XX]XrXXYYAYGYYYYZ!ZEZKZZZZ[E[K[[[\+\P\\\]]@]F]]]^^Y^^^_5_?_t____`+`k``````a8a<a=aaab bVbbbcccScYcccd*d0d{ddee=eJeUe~eeeef>f^fgfmffffffg&g6g\g]gggh)h^h_hhhiIiziiiiijj7jVj`jjjjk5k;kIkkkkllFlvlwllllllm=mmnnHnNnnnno$oHoNoooopBpHpppq&qKqqqrr;rArrrssTssst,t6tittttuu^uuuuuuv'v+v,vrvxvvwDwwwxx xAxGxxxyyyiyyzz)z6zAzjzqzzz{*{J{S{Y{{{{{{|||B|C|u|{|} }:};}}}~$~U~[~i~~~~%/lcms$RS|~aef12~UV"WXK,x9~CQ:D*EV]/iAGy<BHwD_%JQUV W2Kd}+5;,W $g6ouK)]DA-3EK%+v<BL>gh &,^P6qw9r0g9ioH?vT d[g28|+s>*+NTG J)*QWJ Q34_e(o$*y7syD N4ag"23Tde Ba%Oop‹‘»'GHciÓóô ;AkċČħĭCcdŅů;<W]ƇƧƨ/5_ǀǛǡ 7WXsyȣ/0KQ{ɛɜɷɽ#)Sstʏʕʿ+KLgm˗˷˸#$?Eȍ̫̱̐Ggh͉̓ͳ?@[a΋Ϋά39cστϟϥ ;[\w}Ч34OUџѠѻ  '-Wwxғҙ/OPkqӛӻӼ'(CIsԓԔԯԵ!KklՇՍշ#CD_e֏ְ֯7=gׇ׈ףש?_`{؁ث78SYك٣٤ٿ+1[{|ڗڝ 3STou۟ۿ +,GMwܗܘܹܳ%Oop݋ݑݻ'GHciޓ޳޴ ;Akߋߌߧ߭Ccd;<W]/5_ 7WXsy/0KQ{#)Sst+KLgm#$?EoGgh?@[a39c ;[\w}34OU  '-Wwx/OPkq'(CIs!Kkl#CD_e7=g?_`{78SY+1[{| 3STou +,GMw%Oop'GHci ;AkCcd;<W]/5_ 7WXsy/0KQ{#)Sst+KLgm#$?EoGgh?@[a39c ;[\w}34OU  '-Wwx  / O P k q       ' ( C I s         ! K k l        # C D _ e         7 = g       ?_`{78SY+1[{| 3STou +,GMw%Oop'GHci ;AkCcd;<W]/5_ 7WXsy/0KQ{#)Sst+KLgm#$?EoGgh?@[a   3 9 c       ! !!;![!\!w!}!!!!!""3"4"O"U""""""# # #'#-#W#w#x######$$/$O$P$k$q$$$$$%%'%(%C%I%s%%%%%%&&&!&K&k&l&&&&&&&'#'C'D'_'e''''''(((7(=(g((((((()))?)_)`){))))))**7*8*S*Y******+++++1+[+{+|+++++,, ,3,S,T,o,u,,,,,- -+-,-G-M-w-----...7.=...//_///0B001!161<1111292?2|222333M3344$4i44455W55556"6c666777`77888R8X889'9D9E999::e::::::;@;;;<4<]>b>>>>>>>?H?\?b??@@V@@@AAAA1A7AAAB BTBBBC C'C(CaCgCCD#DfDDDE?EfEEEF=F[F]F^FzF~FFGG>GGGGHHH"HGHHHiHHHHHHIII7IDIEIlIyIzIIIIIIJ.JGJ`JyJJJJJKK7KWKwKKKKLL7LWLwLLLLMM7MWMwMMMMNN7NWNwNNNNOO7OWOwOOOOPP7PWPwPPPPQQ7QWQwQQQQRR7RWRwRRRRSS7SWSwSSSSTT7TWTwTTTTUU7UWUwUUUUVV7VWVwVVVVWW7WWWwWWWWXX7XWXwXXXXYY7YWYwYYYYZZ7ZWZwZZZZ[[7[W[w[[[[\\7\W\w\\\\]]7]W]w]]]]^^7^W^w^^^^__7_W_w____``7`W`w````aa7aWawaaaabb7bWbwbbbbcc7cWcwccccdd7dWdwddddee7eWeweeeeff7fWfwffffgg7gWgwgggghh7hWhwhhhhii7iWiwiiiijj7jWjwjjjjk(kEkFkkl l8l9llllmmmRmjmkmmmnn+n,ntnnnnno*o<o=ooooppp`p}p~pppq4qxqqqrr3r7rwrrrss&sXssssttt*tStTtkttttttuuu.uWuXuuuuv(v;v<vvvvvvwwww*w+wwwwwwxxx2x3x}xxxxy y yOyqyryyy ByteBuffer TypedData TypedDataList _TypedIntList_TypedFloatListEndianByteDataInt8List Uint8ListUint8ClampedList Int16List Uint16List Int32List Uint32List Int64List Uint64List Float32List Float64List Float32x4List Int32x4List Float64x2List Float32x4Int32x4 Float64x2ȿ