@openclaw/whatsapp 2026.9.6 → 2026.9.8

package/node_modules/audio-decode/node_modules/@audio/decode-vorbis/decode-vorbis.js

@@ -0,0 +1,2984 @@
+// ../../node_modules/simple-yenc/dist/esm.js
+var t = (t2, n = 4294967295, e2 = 79764919) => {
+  const r = new Int32Array(256);
+  let o, s, i, c = n;
+  for (o = 0; o < 256; o++) {
+    for (i = o << 24, s = 8; s > 0; --s) i = 2147483648 & i ? i << 1 ^ e2 : i << 1;
+    r[o] = i;
+  }
+  for (o = 0; o < t2.length; o++) c = c << 8 ^ r[255 & (c >> 24 ^ t2[o])];
+  return c;
+};
+var e = (n, e2 = t) => {
+  const r = (t2) => new Uint8Array(t2.length / 2).map(((n2, e3) => parseInt(t2.substring(2 * e3, 2 * (e3 + 1)), 16))), o = (t2) => r(t2)[0], s = /* @__PURE__ */ new Map();
+  [, 8364, , 8218, 402, 8222, 8230, 8224, 8225, 710, 8240, 352, 8249, 338, , 381, , , 8216, 8217, 8220, 8221, 8226, 8211, 8212, 732, 8482, 353, 8250, 339, , 382, 376].forEach(((t2, n2) => s.set(t2, n2)));
+  const i = new Uint8Array(n.length);
+  let c, a, l, f = false, g = 0, h = 42, p = n.length > 13 && "dynEncode" === n.substring(0, 9), u = 0;
+  p && (u = 11, a = o(n.substring(9, u)), a <= 1 && (u += 2, h = o(n.substring(11, u))), 1 === a && (u += 8, l = ((t2) => new DataView(r(t2).buffer).getInt32(0, true))(n.substring(13, u))));
+  const d = 256 - h;
+  for (let t2 = u; t2 < n.length; t2++) if (c = n.charCodeAt(t2), 61 !== c || f) {
+    if (92 === c && t2 < n.length - 5 && p) {
+      const e3 = n.charCodeAt(t2 + 1);
+      117 !== e3 && 85 !== e3 || (c = parseInt(n.substring(t2 + 2, t2 + 6), 16), t2 += 5);
+    }
+    if (c > 255) {
+      const t3 = s.get(c);
+      t3 && (c = t3 + 127);
+    }
+    f && (f = false, c -= 64), i[g++] = c < h && c > 0 ? c + d : c - h;
+  } else f = true;
+  const m = i.subarray(0, g);
+  if (p && 1 === a) {
+    const t2 = e2(m);
+    if (t2 !== l) {
+      const n2 = "Decode failed crc32 validation";
+      throw console.error("`simple-yenc`\n", n2 + "\n", "Expected: " + l + "; Got: " + t2 + "\n", "Visit https://github.com/eshaz/simple-yenc for more information"), Error(n2);
+    }
+  }
+  return m;
+};
+
+// ../../node_modules/@wasm-audio-decoders/common/src/WASMAudioDecoderCommon.js
+function WASMAudioDecoderCommon() {
+  const uint8Array2 = Uint8Array;
+  const float32Array = Float32Array;
+  if (!WASMAudioDecoderCommon.modules) {
+    Object.defineProperties(WASMAudioDecoderCommon, {
+      modules: {
+        value: /* @__PURE__ */ new WeakMap()
+      },
+      setModule: {
+        value(Ref, module) {
+          WASMAudioDecoderCommon.modules.set(Ref, Promise.resolve(module));
+        }
+      },
+      getModule: {
+        value(Ref, wasmString) {
+          let module = WASMAudioDecoderCommon.modules.get(Ref);
+          if (!module) {
+            if (!wasmString) {
+              wasmString = Ref.wasm;
+              module = WASMAudioDecoderCommon.inflateDynEncodeString(
+                wasmString
+              ).then((data3) => WebAssembly.compile(data3));
+            } else {
+              module = WebAssembly.compile(e(wasmString));
+            }
+            WASMAudioDecoderCommon.modules.set(Ref, module);
+          }
+          return module;
+        }
+      },
+      concatFloat32: {
+        value(buffers, length2) {
+          let ret = new float32Array(length2), i = 0, offset = 0;
+          while (i < buffers.length) {
+            ret.set(buffers[i], offset);
+            offset += buffers[i++].length;
+          }
+          return ret;
+        }
+      },
+      getDecodedAudio: {
+        value: (errors, channelData, samplesDecoded, sampleRate2, bitDepth2) => ({
+          errors,
+          channelData,
+          samplesDecoded,
+          sampleRate: sampleRate2,
+          bitDepth: bitDepth2
+        })
+      },
+      getDecodedAudioMultiChannel: {
+        value(errors, input, channelsDecoded, samplesDecoded, sampleRate2, bitDepth2) {
+          let channelData = [], i, j;
+          for (i = 0; i < channelsDecoded; i++) {
+            const channel2 = [];
+            for (j = 0; j < input.length; ) channel2.push(input[j++][i] || []);
+            channelData.push(
+              WASMAudioDecoderCommon.concatFloat32(channel2, samplesDecoded)
+            );
+          }
+          return WASMAudioDecoderCommon.getDecodedAudio(
+            errors,
+            channelData,
+            samplesDecoded,
+            sampleRate2,
+            bitDepth2
+          );
+        }
+      },
+      /*
+       ******************
+       * Compression Code
+       ******************
+       */
+      inflateDynEncodeString: {
+        value(source) {
+          source = e(source);
+          return new Promise((resolve) => {
+            const puffString = String.raw`dynEncode012804c7886d(‰›•)((()>+ˆ*§§)§ˆ,§§§§)§ˆ+§§§)§+.-()(*)-+)(ˆ.7*§)i¸¸,3§(i¸¸,3/G+.••—š¡*(,˜ŽŽ(,3‡‡‰˜‡Š‰›+)2å:-œ),§H(P*DI*H(P*@I++hH)H*r,hH(H(P*<J,i)’^*<H,H(P*4’U((I-H(H*i0’J,^*DH+H-H*œšI+H,I*4)33H(H*H)“^*DH(H+H)^*@H+i§H)œi§›™3æ*).§K(iH“I/+§H,iHn,§H+i(H+i(rCJ0I,H*I-+hH,,hH(H-V)(i)œ’J.H.W)(i)’c)(H,i)“I,H-i*’I-4)33i(I.*hH(V)(H+n5(H(i*’I-i(I,i)I.+hH,i*’J+iHn,hi(I-i*I,+hH,H/’H-c)(H,iFn,hi(I,+hH,H0n5-H*V)(J(,hH/H(i)œ’J(H(V)(J(i)’c)(H)H(i)œ’H,c)(3H*i*’I*H,i)’I,4(3(-H(H,’W)(H-’I-H,i*’I,4)3(3(3H,H-’I1H+I,H.i)œH1V)(“J.i(v5(33H.-H(H,’i(c)(H,i*’I,4)333–)-§i*I*+§H*iHn,hiž73H,H(i)8(H+šJ+H)P*(H*’V)(J-“r,§H)P*,H.i)œ’H+H,“i)œ’V)(-H*i*’I*H+i)œI+H-H.’I.H,H-’i)œI,4)333Ã+)-§iø7i(^*(iü7I,*h+hH+iDn,h*hilI+i)I,+hH+,hH+iô7’H,c)(i)H+i´8’W)(œH,’I,H+i*’I+4)-+hH(H)8*J-i(p5.*h*h*hH-i')u,hH(P*(J+,hH(P*0J,H(P*,n50H+H,’H-b((3H(P*0i)’I.4)3H-i¨*n5*H-iÅ*s,hiž73H-i)œJ+V)&+I,H(H+V)æ,8(I.H(H*8*J-i(p51H-i)œJ+i¸7’V)(H(H+iø7’V)(8(’J/H(P*0J+s,hi73H+H,H.’J,’I.H(P*(m5(H.H(P*,s5.+hH,m5*H(P*(J.H+’H.H+H/“’U((b((H(H(P*0i)’J+^*0H,i)“I,4(3(3H(H.^*03H-i¨*o5)33i(73(3(3-H,H+i)žc)(H,i*’I,H+i)’I+4)33i)I-3H-3!2)0§K(i2“J,L(H,H(^*(H,H*^*4H,i(^*0H,i(^*DH,j(_*<H,H)P*(^*,H,H+P*(^*8*h*h+hH,i)8(I3i§I**h*h*h*h*h*h*hH,i*8(6+(),03H,j(_*@i*I-H,P*<J.i,’J(H,P*8J/s50H,H.i+’J0^*<i¦I*H.H,P*4J1’J.U(*H.U((J2›i')o5/H.U()I.H,H(^*<H0H1’U((H.i0œJ.i§›i0ži')™o5/H/H.H2šJ*H(’J.q50H,P*0J/H*’I-H,P*(J0,hH,P*,H-q,hi)I-423+hH*m5+H/H0’H(H1’U((b((H/i)’I/H(i)’I(H*i)“I*4(3(3H,H.^*<H,H-^*04*3iØ1U((5+i(I(i¨7i1^*(i$6iè1^*(i°7iè6^*(i¬7iÈ6^*(+hH(iÈ*n,hiÈ*I(+hH(i¨,n,hi¨,I(+hH(iØ,n,hiØ,I(+hH(iè,o,hH,i-’H(’i0c)(H(i*’I(4)33iè1i1H,i-’iÈ*8)Bi(I(+hH(ido,hH,i-’H(’i-c)(H(i*’I(4)33iÈ6iè6H,i-’iF8)BiØ1i)b((41-H,i-’H(’i/c)(H(i*’I(4)3(3(-H,i-’H(’i1c)(H(i*’I(4)3(3(-H,i-’H(’i0c)(H(i*’I(4)3(3(3H,H/^*0H,H(^*<3i(I*4*3H,H,i¸)’^*TH,H,iø-’^*PH,H,iX’^*LH,H,i(’^*HH,i-8(I(H,i-8(I-i¥I*H,i,8(I.H(iErH-iErš5)H(i©*’I1H-i)’I0i(i;H.i,’J(i(H(i(rCJ(“J*H*i;sCI*i¨1I-H(I/+hH/,hH,i-’H-V)(i)œ’H,i+8(c)(H/i)“I/H-i*’I-H*i)’I*4)-H(i)œi¨1’I/+hH(H*o,hH,i-’H/V)(i)œ’i(c)(H/i*’I/H(i)’I(4)33i¤I*H,iø-’H,i¸)’H,i-’i;8)5+H0H1’I2i(I-+hH-H2p,hH,H,iP’8*J*i(p5-H*i7u,hH,i-’H-i)œ’H*c)(H-i)’I-4*3i(I/i+I.i+I(*h*h*hH*i8“6*(*)3H-m,hi£I*403H-i)œH,’W)-I/i*I(4)3i3I.i/I(3H2H,H(8(H.’J(H-’J.p,hi¢I*4.3H,i-’H-i)œ’I*+hH(,hH*H/c)(H*i*’I*H(i)“I(4)-H.I-4+3(3(33H,W)1m,hiŸI*4,3H,iø-’H,i¸)’H,i-’H18)J(,hi¡I*H(i(p5,H1H,V)ú-H,V)ø-’o5,3H,i(’H,iX’H,i-’H1i)œ’H08)J(,hi I*H(i(p5,H0H,V)šH,V)˜’o5,3H,H,iP’H,iH’8+I*4+3(3(3H,i$6i¬78+I*3H*H3šm5(3i)I-H*i(r5)3H)H,P*0^*(H+H,P*<^*(H*I-3H,i2’L(H-33Á)+(i¨03b+(,(-(.(/(0(1(2(3(5(7(9(;(?(C(G(K(S([(c(k({(‹(›(«(Ë(ë((*)(iø03O)()()()(*(*(*(*(+(+(+(+(,(,(,(,(-(-(-(-(i¨13M8(9(:(((0(/(1(.(2(-(3(,(4(+(5(*(6()(7(T7œ‰šœ‡Ž‰œš›*S7•œ‰Š”U”—Š‰”›S0›‘–U œ`;
+            WASMAudioDecoderCommon.getModule(WASMAudioDecoderCommon, puffString).then((wasm) => WebAssembly.instantiate(wasm, {})).then(({ exports }) => {
+              const instanceExports = new Map(Object.entries(exports));
+              const puff = instanceExports.get("puff");
+              const memory = instanceExports.get("memory")["buffer"];
+              const dataArray = new uint8Array2(memory);
+              const heapView = new DataView(memory);
+              let heapPos = instanceExports.get("__heap_base");
+              const sourceLength = source.length;
+              const sourceLengthPtr = heapPos;
+              heapPos += 4;
+              heapView.setInt32(sourceLengthPtr, sourceLength, true);
+              const sourcePtr = heapPos;
+              heapPos += sourceLength;
+              dataArray.set(source, sourcePtr);
+              const destLengthPtr = heapPos;
+              heapPos += 4;
+              heapView.setInt32(
+                destLengthPtr,
+                dataArray.byteLength - heapPos,
+                true
+              );
+              puff(heapPos, destLengthPtr, sourcePtr, sourceLengthPtr);
+              resolve(
+                dataArray.slice(
+                  heapPos,
+                  heapPos + heapView.getInt32(destLengthPtr, true)
+                )
+              );
+            });
+          });
+        }
+      }
+    });
+  }
+  Object.defineProperty(this, "wasm", {
+    enumerable: true,
+    get: () => this._wasm
+  });
+  this.getOutputChannels = (outputData, channelsDecoded, samplesDecoded) => {
+    let output = [], i = 0;
+    while (i < channelsDecoded)
+      output.push(
+        outputData.slice(
+          i * samplesDecoded,
+          i++ * samplesDecoded + samplesDecoded
+        )
+      );
+    return output;
+  };
+  this.allocateTypedArray = (len, TypedArray, setPointer = true) => {
+    const ptr = this._wasm.malloc(TypedArray.BYTES_PER_ELEMENT * len);
+    if (setPointer) this._pointers.add(ptr);
+    return {
+      ptr,
+      len,
+      buf: new TypedArray(this._wasm.HEAP, ptr, len)
+    };
+  };
+  this.free = () => {
+    this._pointers.forEach((ptr) => {
+      this._wasm.free(ptr);
+    });
+    this._pointers.clear();
+  };
+  this.codeToString = (ptr) => {
+    const characters = [], heap = new Uint8Array(this._wasm.HEAP);
+    for (let character = heap[ptr]; character !== 0; character = heap[++ptr])
+      characters.push(character);
+    return String.fromCharCode.apply(null, characters);
+  };
+  this.addError = (errors, message, frameLength2, frameNumber2, inputBytes, outputSamples) => {
+    errors.push({
+      message,
+      frameLength: frameLength2,
+      frameNumber: frameNumber2,
+      inputBytes,
+      outputSamples
+    });
+  };
+  this.instantiate = (_EmscriptenWASM, _module) => {
+    if (_module) WASMAudioDecoderCommon.setModule(_EmscriptenWASM, _module);
+    this._wasm = new _EmscriptenWASM(WASMAudioDecoderCommon).instantiate();
+    this._pointers = /* @__PURE__ */ new Set();
+    return this._wasm.ready.then(() => this);
+  };
+}
+
+// ../../node_modules/codec-parser/src/constants.js
+var symbol = Symbol;
+var mappingJoin = ", ";
+var channelMappings = (() => {
+  const front = "front";
+  const side = "side";
+  const rear = "rear";
+  const left = "left";
+  const center = "center";
+  const right = "right";
+  return ["", front + " ", side + " ", rear + " "].map(
+    (x) => [
+      [left, right],
+      [left, right, center],
+      [left, center, right],
+      [center, left, right],
+      [center]
+    ].flatMap((y) => y.map((z) => x + z).join(mappingJoin))
+  );
+})();
+var lfe = "LFE";
+var monophonic = "monophonic (mono)";
+var stereo = "stereo";
+var surround = "surround";
+var getChannelMapping = (channelCount, ...mappings) => `${[
+  monophonic,
+  stereo,
+  `linear ${surround}`,
+  "quadraphonic",
+  `5.0 ${surround}`,
+  `5.1 ${surround}`,
+  `6.1 ${surround}`,
+  `7.1 ${surround}`
+][channelCount - 1]} (${mappings.join(mappingJoin)})`;
+var vorbisOpusChannelMapping = [
+  monophonic,
+  getChannelMapping(2, channelMappings[0][0]),
+  getChannelMapping(3, channelMappings[0][2]),
+  getChannelMapping(4, channelMappings[1][0], channelMappings[3][0]),
+  getChannelMapping(5, channelMappings[1][2], channelMappings[3][0]),
+  getChannelMapping(6, channelMappings[1][2], channelMappings[3][0], lfe),
+  getChannelMapping(7, channelMappings[1][2], channelMappings[2][0], channelMappings[3][4], lfe),
+  getChannelMapping(8, channelMappings[1][2], channelMappings[2][0], channelMappings[3][0], lfe)
+];
+var rate192000 = 192e3;
+var rate176400 = 176400;
+var rate96000 = 96e3;
+var rate88200 = 88200;
+var rate64000 = 64e3;
+var rate48000 = 48e3;
+var rate44100 = 44100;
+var rate32000 = 32e3;
+var rate24000 = 24e3;
+var rate22050 = 22050;
+var rate16000 = 16e3;
+var rate12000 = 12e3;
+var rate11025 = 11025;
+var rate8000 = 8e3;
+var rate7350 = 7350;
+var absoluteGranulePosition = "absoluteGranulePosition";
+var bandwidth = "bandwidth";
+var bitDepth = "bitDepth";
+var bitrate = "bitrate";
+var bitrateMaximum = bitrate + "Maximum";
+var bitrateMinimum = bitrate + "Minimum";
+var bitrateNominal = bitrate + "Nominal";
+var buffer = "buffer";
+var bufferFullness = buffer + "Fullness";
+var codec = "codec";
+var codecFrames = codec + "Frames";
+var coupledStreamCount = "coupledStreamCount";
+var crc = "crc";
+var crc16 = crc + "16";
+var crc32 = crc + "32";
+var data = "data";
+var description = "description";
+var duration = "duration";
+var emphasis = "emphasis";
+var hasOpusPadding = "hasOpusPadding";
+var header = "header";
+var isContinuedPacket = "isContinuedPacket";
+var isCopyrighted = "isCopyrighted";
+var isFirstPage = "isFirstPage";
+var isHome = "isHome";
+var isLastPage = "isLastPage";
+var isOriginal = "isOriginal";
+var isPrivate = "isPrivate";
+var isVbr = "isVbr";
+var layer = "layer";
+var length = "length";
+var mode = "mode";
+var modeExtension = mode + "Extension";
+var mpeg = "mpeg";
+var mpegVersion = mpeg + "Version";
+var numberAACFrames = "numberAACFrames";
+var outputGain = "outputGain";
+var preSkip = "preSkip";
+var profile = "profile";
+var profileBits = symbol();
+var protection = "protection";
+var rawData = "rawData";
+var segments = "segments";
+var subarray = "subarray";
+var version = "version";
+var vorbis = "vorbis";
+var vorbisComments = vorbis + "Comments";
+var vorbisSetup = vorbis + "Setup";
+var block = "block";
+var blockingStrategy = block + "ingStrategy";
+var blockingStrategyBits = symbol();
+var blockSize = block + "Size";
+var blocksize0 = block + "size0";
+var blocksize1 = block + "size1";
+var blockSizeBits = symbol();
+var channel = "channel";
+var channelMappingFamily = channel + "MappingFamily";
+var channelMappingTable = channel + "MappingTable";
+var channelMode = channel + "Mode";
+var channelModeBits = symbol();
+var channels = channel + "s";
+var copyright = "copyright";
+var copyrightId = copyright + "Id";
+var copyrightIdStart = copyright + "IdStart";
+var frame = "frame";
+var frameCount = frame + "Count";
+var frameLength = frame + "Length";
+var Number2 = "Number";
+var frameNumber = frame + Number2;
+var framePadding = frame + "Padding";
+var frameSize = frame + "Size";
+var Rate = "Rate";
+var inputSampleRate = "inputSample" + Rate;
+var page = "page";
+var pageChecksum = page + "Checksum";
+var pageSegmentBytes = symbol();
+var pageSegmentTable = page + "SegmentTable";
+var pageSequenceNumber = page + "Sequence" + Number2;
+var sample = "sample";
+var sampleNumber = sample + Number2;
+var sampleRate = sample + Rate;
+var sampleRateBits = symbol();
+var samples = sample + "s";
+var stream = "stream";
+var streamCount = stream + "Count";
+var streamInfo = stream + "Info";
+var streamSerialNumber = stream + "Serial" + Number2;
+var streamStructureVersion = stream + "StructureVersion";
+var total = "total";
+var totalBytesOut = total + "BytesOut";
+var totalDuration = total + "Duration";
+var totalSamples = total + "Samples";
+var readRawData = symbol();
+var incrementRawData = symbol();
+var mapCodecFrameStats = symbol();
+var mapFrameStats = symbol();
+var logWarning = symbol();
+var logError2 = symbol();
+var syncFrame = symbol();
+var fixedLengthFrameSync = symbol();
+var getHeader = symbol();
+var setHeader = symbol();
+var getFrame = symbol();
+var parseFrame = symbol();
+var parseOggPage = symbol();
+var checkCodecUpdate = symbol();
+var reset = symbol();
+var enable = symbol();
+var getHeaderFromUint8Array = symbol();
+var checkFrameFooterCrc16 = symbol();
+var uint8Array = Uint8Array;
+var dataView = DataView;
+var reserved = "reserved";
+var bad = "bad";
+var free = "free";
+var none = "none";
+var sixteenBitCRC = "16bit CRC";
+
+// ../../node_modules/codec-parser/src/utilities.js
+var getCrcTable = (crcTable, crcInitialValueFunction, crcFunction) => {
+  for (let byte = 0; byte < crcTable[length]; byte++) {
+    let crc2 = crcInitialValueFunction(byte);
+    for (let bit = 8; bit > 0; bit--) crc2 = crcFunction(crc2);
+    crcTable[byte] = crc2;
+  }
+  return crcTable;
+};
+var crc8Table = getCrcTable(
+  new uint8Array(256),
+  (b) => b,
+  (crc2) => crc2 & 128 ? 7 ^ crc2 << 1 : crc2 << 1
+);
+var flacCrc16Table = [
+  getCrcTable(
+    new Uint16Array(256),
+    (b) => b << 8,
+    (crc2) => crc2 << 1 ^ (crc2 & 1 << 15 ? 32773 : 0)
+  )
+];
+var crc32Table = [
+  getCrcTable(
+    new Uint32Array(256),
+    (b) => b,
+    (crc2) => crc2 >>> 1 ^ (crc2 & 1) * 3988292384
+  )
+];
+for (let i = 0; i < 15; i++) {
+  flacCrc16Table.push(new Uint16Array(256));
+  crc32Table.push(new Uint32Array(256));
+  for (let j = 0; j <= 255; j++) {
+    flacCrc16Table[i + 1][j] = flacCrc16Table[0][flacCrc16Table[i][j] >>> 8] ^ flacCrc16Table[i][j] << 8;
+    crc32Table[i + 1][j] = crc32Table[i][j] >>> 8 ^ crc32Table[0][crc32Table[i][j] & 255];
+  }
+}
+var crc8 = (data3) => {
+  let crc2 = 0;
+  const dataLength = data3[length];
+  for (let i = 0; i !== dataLength; i++) crc2 = crc8Table[crc2 ^ data3[i]];
+  return crc2;
+};
+var flacCrc16 = (data3) => {
+  const dataLength = data3[length];
+  const crcChunkSize = dataLength - 16;
+  let crc2 = 0;
+  let i = 0;
+  while (i <= crcChunkSize) {
+    crc2 ^= data3[i++] << 8 | data3[i++];
+    crc2 = flacCrc16Table[15][crc2 >> 8] ^ flacCrc16Table[14][crc2 & 255] ^ flacCrc16Table[13][data3[i++]] ^ flacCrc16Table[12][data3[i++]] ^ flacCrc16Table[11][data3[i++]] ^ flacCrc16Table[10][data3[i++]] ^ flacCrc16Table[9][data3[i++]] ^ flacCrc16Table[8][data3[i++]] ^ flacCrc16Table[7][data3[i++]] ^ flacCrc16Table[6][data3[i++]] ^ flacCrc16Table[5][data3[i++]] ^ flacCrc16Table[4][data3[i++]] ^ flacCrc16Table[3][data3[i++]] ^ flacCrc16Table[2][data3[i++]] ^ flacCrc16Table[1][data3[i++]] ^ flacCrc16Table[0][data3[i++]];
+  }
+  while (i !== dataLength)
+    crc2 = (crc2 & 255) << 8 ^ flacCrc16Table[0][crc2 >> 8 ^ data3[i++]];
+  return crc2;
+};
+var crc32Function = (data3) => {
+  const dataLength = data3[length];
+  const crcChunkSize = dataLength - 16;
+  let crc2 = 0;
+  let i = 0;
+  while (i <= crcChunkSize)
+    crc2 = crc32Table[15][(data3[i++] ^ crc2) & 255] ^ crc32Table[14][(data3[i++] ^ crc2 >>> 8) & 255] ^ crc32Table[13][(data3[i++] ^ crc2 >>> 16) & 255] ^ crc32Table[12][data3[i++] ^ crc2 >>> 24] ^ crc32Table[11][data3[i++]] ^ crc32Table[10][data3[i++]] ^ crc32Table[9][data3[i++]] ^ crc32Table[8][data3[i++]] ^ crc32Table[7][data3[i++]] ^ crc32Table[6][data3[i++]] ^ crc32Table[5][data3[i++]] ^ crc32Table[4][data3[i++]] ^ crc32Table[3][data3[i++]] ^ crc32Table[2][data3[i++]] ^ crc32Table[1][data3[i++]] ^ crc32Table[0][data3[i++]];
+  while (i !== dataLength)
+    crc2 = crc32Table[0][(crc2 ^ data3[i++]) & 255] ^ crc2 >>> 8;
+  return crc2 ^ -1;
+};
+var concatBuffers = (...buffers) => {
+  const buffer2 = new uint8Array(
+    buffers.reduce((acc, buf) => acc + buf[length], 0)
+  );
+  buffers.reduce((offset, buf) => {
+    buffer2.set(buf, offset);
+    return offset + buf[length];
+  }, 0);
+  return buffer2;
+};
+var bytesToString = (bytes) => String.fromCharCode(...bytes);
+var reverseTable = [0, 8, 4, 12, 2, 10, 6, 14, 1, 9, 5, 13, 3, 11, 7, 15];
+var reverse = (val) => reverseTable[val & 15] << 4 | reverseTable[val >> 4];
+var BitReader = class {
+  constructor(data3) {
+    this._data = data3;
+    this._pos = data3[length] * 8;
+  }
+  set position(position) {
+    this._pos = position;
+  }
+  get position() {
+    return this._pos;
+  }
+  read(bits) {
+    const byte = Math.floor(this._pos / 8);
+    const bit = this._pos % 8;
+    this._pos -= bits;
+    const window = (reverse(this._data[byte - 1]) << 8) + reverse(this._data[byte]);
+    return window >> 7 - bit & 255;
+  }
+};
+var readInt64le = (view, offset) => {
+  try {
+    return view.getBigInt64(offset, true);
+  } catch {
+    const sign = view.getUint8(offset + 7) & 128 ? -1 : 1;
+    let firstPart = view.getUint32(offset, true);
+    let secondPart = view.getUint32(offset + 4, true);
+    if (sign === -1) {
+      firstPart = ~firstPart + 1;
+      secondPart = ~secondPart + 1;
+    }
+    if (secondPart > 1048575) {
+      console.warn("This platform does not support BigInt");
+    }
+    return sign * (firstPart + secondPart * 2 ** 32);
+  }
+};
+
+// ../../node_modules/codec-parser/src/codecs/HeaderCache.js
+var HeaderCache = class {
+  constructor(onCodecHeader, onCodecUpdate) {
+    this._onCodecHeader = onCodecHeader;
+    this._onCodecUpdate = onCodecUpdate;
+    this[reset]();
+  }
+  [enable]() {
+    this._isEnabled = true;
+  }
+  [reset]() {
+    this._headerCache = /* @__PURE__ */ new Map();
+    this._codecUpdateData = /* @__PURE__ */ new WeakMap();
+    this._codecHeaderSent = false;
+    this._codecShouldUpdate = false;
+    this._bitrate = null;
+    this._isEnabled = false;
+  }
+  [checkCodecUpdate](bitrate2, totalDuration2) {
+    if (this._onCodecUpdate) {
+      if (this._bitrate !== bitrate2) {
+        this._bitrate = bitrate2;
+        this._codecShouldUpdate = true;
+      }
+      const codecData = this._codecUpdateData.get(
+        this._headerCache.get(this._currentHeader)
+      );
+      if (this._codecShouldUpdate && codecData) {
+        this._onCodecUpdate(
+          {
+            bitrate: bitrate2,
+            ...codecData
+          },
+          totalDuration2
+        );
+      }
+      this._codecShouldUpdate = false;
+    }
+  }
+  [getHeader](key) {
+    const header3 = this._headerCache.get(key);
+    if (header3) {
+      this._updateCurrentHeader(key);
+    }
+    return header3;
+  }
+  [setHeader](key, header3, codecUpdateFields) {
+    if (this._isEnabled) {
+      if (!this._codecHeaderSent) {
+        this._onCodecHeader({ ...header3 });
+        this._codecHeaderSent = true;
+      }
+      this._updateCurrentHeader(key);
+      this._headerCache.set(key, header3);
+      this._codecUpdateData.set(header3, codecUpdateFields);
+    }
+  }
+  _updateCurrentHeader(key) {
+    if (this._onCodecUpdate && key !== this._currentHeader) {
+      this._codecShouldUpdate = true;
+      this._currentHeader = key;
+    }
+  }
+};
+
+// ../../node_modules/codec-parser/src/globals.js
+var headerStore = /* @__PURE__ */ new WeakMap();
+var frameStore = /* @__PURE__ */ new WeakMap();
+
+// ../../node_modules/codec-parser/src/codecs/Parser.js
+var Parser = class {
+  constructor(codecParser, headerCache) {
+    this._codecParser = codecParser;
+    this._headerCache = headerCache;
+  }
+  *[syncFrame]() {
+    let frameData;
+    do {
+      frameData = yield* this.Frame[getFrame](
+        this._codecParser,
+        this._headerCache,
+        0
+      );
+      if (frameData) return frameData;
+      this._codecParser[incrementRawData](1);
+    } while (true);
+  }
+  /**
+   * @description Searches for Frames within bytes containing a sequence of known codec frames.
+   * @param {boolean} ignoreNextFrame Set to true to return frames even if the next frame may not exist at the expected location
+   * @returns {Frame}
+   */
+  *[fixedLengthFrameSync](ignoreNextFrame) {
+    let frameData = yield* this[syncFrame]();
+    const frameLength2 = frameStore.get(frameData)[length];
+    if (ignoreNextFrame || this._codecParser._flushing || // check if there is a frame right after this one
+    (yield* this.Header[getHeader](
+      this._codecParser,
+      this._headerCache,
+      frameLength2
+    ))) {
+      this._headerCache[enable]();
+      this._codecParser[incrementRawData](frameLength2);
+      this._codecParser[mapFrameStats](frameData);
+      return frameData;
+    }
+    this._codecParser[logWarning](
+      `Missing ${frame} at ${frameLength2} bytes from current position.`,
+      `Dropping current ${frame} and trying again.`
+    );
+    this._headerCache[reset]();
+    this._codecParser[incrementRawData](1);
+  }
+};
+
+// ../../node_modules/codec-parser/src/containers/Frame.js
+var Frame = class {
+  constructor(headerValue, dataValue) {
+    frameStore.set(this, { [header]: headerValue });
+    this[data] = dataValue;
+  }
+};
+
+// ../../node_modules/codec-parser/src/codecs/CodecFrame.js
+var CodecFrame = class extends Frame {
+  static *[getFrame](Header, Frame2, codecParser, headerCache, readOffset) {
+    const headerValue = yield* Header[getHeader](
+      codecParser,
+      headerCache,
+      readOffset
+    );
+    if (headerValue) {
+      const frameLengthValue = headerStore.get(headerValue)[frameLength];
+      const samplesValue = headerStore.get(headerValue)[samples];
+      const frame2 = (yield* codecParser[readRawData](
+        frameLengthValue,
+        readOffset
+      ))[subarray](0, frameLengthValue);
+      return new Frame2(headerValue, frame2, samplesValue);
+    } else {
+      return null;
+    }
+  }
+  constructor(headerValue, dataValue, samplesValue) {
+    super(headerValue, dataValue);
+    this[header] = headerValue;
+    this[samples] = samplesValue;
+    this[duration] = samplesValue / headerValue[sampleRate] * 1e3;
+    this[frameNumber] = null;
+    this[totalBytesOut] = null;
+    this[totalSamples] = null;
+    this[totalDuration] = null;
+    frameStore.get(this)[length] = dataValue[length];
+  }
+};
+
+// ../../node_modules/codec-parser/src/metadata/ID3v2.js
+var unsynchronizationFlag = "unsynchronizationFlag";
+var extendedHeaderFlag = "extendedHeaderFlag";
+var experimentalFlag = "experimentalFlag";
+var footerPresent = "footerPresent";
+var ID3v2 = class _ID3v2 {
+  static *getID3v2Header(codecParser, headerCache, readOffset) {
+    const headerLength = 10;
+    const header3 = {};
+    let data3 = yield* codecParser[readRawData](3, readOffset);
+    if (data3[0] !== 73 || data3[1] !== 68 || data3[2] !== 51) return null;
+    data3 = yield* codecParser[readRawData](headerLength, readOffset);
+    header3[version] = `id3v2.${data3[3]}.${data3[4]}`;
+    if (data3[5] & 15) return null;
+    header3[unsynchronizationFlag] = !!(data3[5] & 128);
+    header3[extendedHeaderFlag] = !!(data3[5] & 64);
+    header3[experimentalFlag] = !!(data3[5] & 32);
+    header3[footerPresent] = !!(data3[5] & 16);
+    if (data3[6] & 128 || data3[7] & 128 || data3[8] & 128 || data3[9] & 128)
+      return null;
+    const dataLength = data3[6] << 21 | data3[7] << 14 | data3[8] << 7 | data3[9];
+    header3[length] = headerLength + dataLength;
+    return new _ID3v2(header3);
+  }
+  constructor(header3) {
+    this[version] = header3[version];
+    this[unsynchronizationFlag] = header3[unsynchronizationFlag];
+    this[extendedHeaderFlag] = header3[extendedHeaderFlag];
+    this[experimentalFlag] = header3[experimentalFlag];
+    this[footerPresent] = header3[footerPresent];
+    this[length] = header3[length];
+  }
+};
+
+// ../../node_modules/codec-parser/src/codecs/CodecHeader.js
+var CodecHeader = class {
+  /**
+   * @private
+   */
+  constructor(header3) {
+    headerStore.set(this, header3);
+    this[bitDepth] = header3[bitDepth];
+    this[bitrate] = null;
+    this[channels] = header3[channels];
+    this[channelMode] = header3[channelMode];
+    this[sampleRate] = header3[sampleRate];
+  }
+};
+
+// ../../node_modules/codec-parser/src/codecs/mpeg/MPEGHeader.js
+var bitrateMatrix = {
+  // bits | V1,L1 | V1,L2 | V1,L3 | V2,L1 | V2,L2 & L3
+  0: [free, free, free, free, free],
+  16: [32, 32, 32, 32, 8],
+  // 0b00100000: [64,   48,  40,  48,  16,],
+  // 0b00110000: [96,   56,  48,  56,  24,],
+  // 0b01000000: [128,  64,  56,  64,  32,],
+  // 0b01010000: [160,  80,  64,  80,  40,],
+  // 0b01100000: [192,  96,  80,  96,  48,],
+  // 0b01110000: [224, 112,  96, 112,  56,],
+  // 0b10000000: [256, 128, 112, 128,  64,],
+  // 0b10010000: [288, 160, 128, 144,  80,],
+  // 0b10100000: [320, 192, 160, 160,  96,],
+  // 0b10110000: [352, 224, 192, 176, 112,],
+  // 0b11000000: [384, 256, 224, 192, 128,],
+  // 0b11010000: [416, 320, 256, 224, 144,],
+  // 0b11100000: [448, 384, 320, 256, 160,],
+  240: [bad, bad, bad, bad, bad]
+};
+var calcBitrate = (idx, interval, intervalOffset) => 8 * ((idx + intervalOffset) % interval + interval) * (1 << (idx + intervalOffset) / interval) - 8 * interval * (interval / 8 | 0);
+for (let i = 2; i < 15; i++)
+  bitrateMatrix[i << 4] = [
+    i * 32,
+    //                V1,L1
+    calcBitrate(i, 4, 0),
+    //  V1,L2
+    calcBitrate(i, 4, -1),
+    // V1,L3
+    calcBitrate(i, 8, 4),
+    //  V2,L1
+    calcBitrate(i, 8, 0)
+    //  V2,L2 & L3
+  ];
+var v1Layer1 = 0;
+var v1Layer2 = 1;
+var v1Layer3 = 2;
+var v2Layer1 = 3;
+var v2Layer23 = 4;
+var bands = "bands ";
+var to31 = " to 31";
+var layer12ModeExtensions = {
+  0: bands + 4 + to31,
+  16: bands + 8 + to31,
+  32: bands + 12 + to31,
+  48: bands + 16 + to31
+};
+var bitrateIndex = "bitrateIndex";
+var v2 = "v2";
+var v1 = "v1";
+var intensityStereo = "Intensity stereo ";
+var msStereo = ", MS stereo ";
+var on = "on";
+var off = "off";
+var layer3ModeExtensions = {
+  0: intensityStereo + off + msStereo + off,
+  16: intensityStereo + on + msStereo + off,
+  32: intensityStereo + off + msStereo + on,
+  48: intensityStereo + on + msStereo + on
+};
+var layersValues = {
+  0: { [description]: reserved },
+  2: {
+    [description]: "Layer III",
+    [framePadding]: 1,
+    [modeExtension]: layer3ModeExtensions,
+    [v1]: {
+      [bitrateIndex]: v1Layer3,
+      [samples]: 1152
+    },
+    [v2]: {
+      [bitrateIndex]: v2Layer23,
+      [samples]: 576
+    }
+  },
+  4: {
+    [description]: "Layer II",
+    [framePadding]: 1,
+    [modeExtension]: layer12ModeExtensions,
+    [samples]: 1152,
+    [v1]: {
+      [bitrateIndex]: v1Layer2
+    },
+    [v2]: {
+      [bitrateIndex]: v2Layer23
+    }
+  },
+  6: {
+    [description]: "Layer I",
+    [framePadding]: 4,
+    [modeExtension]: layer12ModeExtensions,
+    [samples]: 384,
+    [v1]: {
+      [bitrateIndex]: v1Layer1
+    },
+    [v2]: {
+      [bitrateIndex]: v2Layer1
+    }
+  }
+};
+var mpegVersionDescription = "MPEG Version ";
+var isoIec = "ISO/IEC ";
+var mpegVersions = {
+  0: {
+    [description]: `${mpegVersionDescription}2.5 (later extension of MPEG 2)`,
+    [layer]: v2,
+    [sampleRate]: {
+      0: rate11025,
+      4: rate12000,
+      8: rate8000,
+      12: reserved
+    }
+  },
+  8: { [description]: reserved },
+  16: {
+    [description]: `${mpegVersionDescription}2 (${isoIec}13818-3)`,
+    [layer]: v2,
+    [sampleRate]: {
+      0: rate22050,
+      4: rate24000,
+      8: rate16000,
+      12: reserved
+    }
+  },
+  24: {
+    [description]: `${mpegVersionDescription}1 (${isoIec}11172-3)`,
+    [layer]: v1,
+    [sampleRate]: {
+      0: rate44100,
+      4: rate48000,
+      8: rate32000,
+      12: reserved
+    }
+  },
+  length
+};
+var protectionValues = {
+  0: sixteenBitCRC,
+  1: none
+};
+var emphasisValues = {
+  0: none,
+  1: "50/15 ms",
+  2: reserved,
+  3: "CCIT J.17"
+};
+var channelModes = {
+  0: { [channels]: 2, [description]: stereo },
+  64: { [channels]: 2, [description]: "joint " + stereo },
+  128: { [channels]: 2, [description]: "dual channel" },
+  192: { [channels]: 1, [description]: monophonic }
+};
+var MPEGHeader = class _MPEGHeader extends CodecHeader {
+  static *[getHeader](codecParser, headerCache, readOffset) {
+    const header3 = {};
+    const id3v2Header = yield* ID3v2.getID3v2Header(
+      codecParser,
+      headerCache,
+      readOffset
+    );
+    if (id3v2Header) {
+      yield* codecParser[readRawData](id3v2Header[length], readOffset);
+      codecParser[incrementRawData](id3v2Header[length]);
+    }
+    const data3 = yield* codecParser[readRawData](4, readOffset);
+    const key = bytesToString(data3[subarray](0, 4));
+    const cachedHeader = headerCache[getHeader](key);
+    if (cachedHeader) return new _MPEGHeader(cachedHeader);
+    if (data3[0] !== 255 || data3[1] < 224) return null;
+    const mpegVersionValues2 = mpegVersions[data3[1] & 24];
+    if (mpegVersionValues2[description] === reserved) return null;
+    const layerBits = data3[1] & 6;
+    if (layersValues[layerBits][description] === reserved) return null;
+    const layerValues2 = {
+      ...layersValues[layerBits],
+      ...layersValues[layerBits][mpegVersionValues2[layer]]
+    };
+    header3[mpegVersion] = mpegVersionValues2[description];
+    header3[layer] = layerValues2[description];
+    header3[samples] = layerValues2[samples];
+    header3[protection] = protectionValues[data3[1] & 1];
+    header3[length] = 4;
+    header3[bitrate] = bitrateMatrix[data3[2] & 240][layerValues2[bitrateIndex]];
+    if (header3[bitrate] === bad) return null;
+    header3[sampleRate] = mpegVersionValues2[sampleRate][data3[2] & 12];
+    if (header3[sampleRate] === reserved) return null;
+    header3[framePadding] = data3[2] & 2 && layerValues2[framePadding];
+    header3[isPrivate] = !!(data3[2] & 1);
+    header3[frameLength] = Math.floor(
+      125 * header3[bitrate] * header3[samples] / header3[sampleRate] + header3[framePadding]
+    );
+    if (!header3[frameLength]) return null;
+    const channelModeBits2 = data3[3] & 192;
+    header3[channelMode] = channelModes[channelModeBits2][description];
+    header3[channels] = channelModes[channelModeBits2][channels];
+    header3[modeExtension] = layerValues2[modeExtension][data3[3] & 48];
+    header3[isCopyrighted] = !!(data3[3] & 8);
+    header3[isOriginal] = !!(data3[3] & 4);
+    header3[emphasis] = emphasisValues[data3[3] & 3];
+    if (header3[emphasis] === reserved) return null;
+    header3[bitDepth] = 16;
+    {
+      const { length: length2, frameLength: frameLength2, samples: samples2, ...codecUpdateFields } = header3;
+      headerCache[setHeader](key, header3, codecUpdateFields);
+    }
+    return new _MPEGHeader(header3);
+  }
+  /**
+   * @private
+   * Call MPEGHeader.getHeader(Array<Uint8>) to get instance
+   */
+  constructor(header3) {
+    super(header3);
+    this[bitrate] = header3[bitrate];
+    this[emphasis] = header3[emphasis];
+    this[framePadding] = header3[framePadding];
+    this[isCopyrighted] = header3[isCopyrighted];
+    this[isOriginal] = header3[isOriginal];
+    this[isPrivate] = header3[isPrivate];
+    this[layer] = header3[layer];
+    this[modeExtension] = header3[modeExtension];
+    this[mpegVersion] = header3[mpegVersion];
+    this[protection] = header3[protection];
+  }
+};
+
+// ../../node_modules/codec-parser/src/codecs/mpeg/MPEGFrame.js
+var MPEGFrame = class _MPEGFrame extends CodecFrame {
+  static *[getFrame](codecParser, headerCache, readOffset) {
+    return yield* super[getFrame](
+      MPEGHeader,
+      _MPEGFrame,
+      codecParser,
+      headerCache,
+      readOffset
+    );
+  }
+  constructor(header3, frame2, samples2) {
+    super(header3, frame2, samples2);
+  }
+};
+
+// ../../node_modules/codec-parser/src/codecs/mpeg/MPEGParser.js
+var MPEGParser = class extends Parser {
+  constructor(codecParser, headerCache, onCodec) {
+    super(codecParser, headerCache);
+    this.Frame = MPEGFrame;
+    this.Header = MPEGHeader;
+    onCodec(this[codec]);
+  }
+  get [codec]() {
+    return mpeg;
+  }
+  *[parseFrame]() {
+    return yield* this[fixedLengthFrameSync]();
+  }
+};
+
+// ../../node_modules/codec-parser/src/codecs/aac/AACHeader.js
+var mpegVersionValues = {
+  0: "MPEG-4",
+  8: "MPEG-2"
+};
+var layerValues = {
+  0: "valid",
+  2: bad,
+  4: bad,
+  6: bad
+};
+var protectionValues2 = {
+  0: sixteenBitCRC,
+  1: none
+};
+var profileValues = {
+  0: "AAC Main",
+  64: "AAC LC (Low Complexity)",
+  128: "AAC SSR (Scalable Sample Rate)",
+  192: "AAC LTP (Long Term Prediction)"
+};
+var sampleRates = {
+  0: rate96000,
+  4: rate88200,
+  8: rate64000,
+  12: rate48000,
+  16: rate44100,
+  20: rate32000,
+  24: rate24000,
+  28: rate22050,
+  32: rate16000,
+  36: rate12000,
+  40: rate11025,
+  44: rate8000,
+  48: rate7350,
+  52: reserved,
+  56: reserved,
+  60: "frequency is written explicitly"
+};
+var channelModeValues = {
+  0: { [channels]: 0, [description]: "Defined in AOT Specific Config" },
+  /*
+  'monophonic (mono)'
+  'stereo (left, right)'
+  'linear surround (front center, front left, front right)'
+  'quadraphonic (front center, front left, front right, rear center)'
+  '5.0 surround (front center, front left, front right, rear left, rear right)'
+  '5.1 surround (front center, front left, front right, rear left, rear right, LFE)'
+  '7.1 surround (front center, front left, front right, side left, side right, rear left, rear right, LFE)'
+  */
+  64: { [channels]: 1, [description]: monophonic },
+  128: { [channels]: 2, [description]: getChannelMapping(2, channelMappings[0][0]) },
+  192: { [channels]: 3, [description]: getChannelMapping(3, channelMappings[1][3]) },
+  256: { [channels]: 4, [description]: getChannelMapping(4, channelMappings[1][3], channelMappings[3][4]) },
+  320: { [channels]: 5, [description]: getChannelMapping(5, channelMappings[1][3], channelMappings[3][0]) },
+  384: { [channels]: 6, [description]: getChannelMapping(6, channelMappings[1][3], channelMappings[3][0], lfe) },
+  448: { [channels]: 8, [description]: getChannelMapping(8, channelMappings[1][3], channelMappings[2][0], channelMappings[3][0], lfe) }
+};
+var AACHeader = class _AACHeader extends CodecHeader {
+  static *[getHeader](codecParser, headerCache, readOffset) {
+    const header3 = {};
+    const data3 = yield* codecParser[readRawData](7, readOffset);
+    const key = bytesToString([
+      data3[0],
+      data3[1],
+      data3[2],
+      data3[3] & 252 | data3[6] & 3
+      // frame length, buffer fullness varies so don't cache it
+    ]);
+    const cachedHeader = headerCache[getHeader](key);
+    if (!cachedHeader) {
+      if (data3[0] !== 255 || data3[1] < 240) return null;
+      header3[mpegVersion] = mpegVersionValues[data3[1] & 8];
+      header3[layer] = layerValues[data3[1] & 6];
+      if (header3[layer] === bad) return null;
+      const protectionBit = data3[1] & 1;
+      header3[protection] = protectionValues2[protectionBit];
+      header3[length] = protectionBit ? 7 : 9;
+      header3[profileBits] = data3[2] & 192;
+      header3[sampleRateBits] = data3[2] & 60;
+      const privateBit = data3[2] & 2;
+      header3[profile] = profileValues[header3[profileBits]];
+      header3[sampleRate] = sampleRates[header3[sampleRateBits]];
+      if (header3[sampleRate] === reserved) return null;
+      header3[isPrivate] = !!privateBit;
+      header3[channelModeBits] = (data3[2] << 8 | data3[3]) & 448;
+      header3[channelMode] = channelModeValues[header3[channelModeBits]][description];
+      header3[channels] = channelModeValues[header3[channelModeBits]][channels];
+      header3[isOriginal] = !!(data3[3] & 32);
+      header3[isHome] = !!(data3[3] & 8);
+      header3[copyrightId] = !!(data3[3] & 8);
+      header3[copyrightIdStart] = !!(data3[3] & 4);
+      header3[bitDepth] = 16;
+      header3[samples] = 1024;
+      header3[numberAACFrames] = data3[6] & 3;
+      {
+        const {
+          length: length2,
+          channelModeBits: channelModeBits2,
+          profileBits: profileBits2,
+          sampleRateBits: sampleRateBits2,
+          frameLength: frameLength2,
+          samples: samples2,
+          numberAACFrames: numberAACFrames2,
+          ...codecUpdateFields
+        } = header3;
+        headerCache[setHeader](key, header3, codecUpdateFields);
+      }
+    } else {
+      Object.assign(header3, cachedHeader);
+    }
+    header3[frameLength] = (data3[3] << 11 | data3[4] << 3 | data3[5] >> 5) & 8191;
+    if (!header3[frameLength]) return null;
+    const bufferFullnessBits = (data3[5] << 6 | data3[6] >> 2) & 2047;
+    header3[bufferFullness] = bufferFullnessBits === 2047 ? "VBR" : bufferFullnessBits;
+    return new _AACHeader(header3);
+  }
+  /**
+   * @private
+   * Call AACHeader.getHeader(Array<Uint8>) to get instance
+   */
+  constructor(header3) {
+    super(header3);
+    this[copyrightId] = header3[copyrightId];
+    this[copyrightIdStart] = header3[copyrightIdStart];
+    this[bufferFullness] = header3[bufferFullness];
+    this[isHome] = header3[isHome];
+    this[isOriginal] = header3[isOriginal];
+    this[isPrivate] = header3[isPrivate];
+    this[layer] = header3[layer];
+    this[length] = header3[length];
+    this[mpegVersion] = header3[mpegVersion];
+    this[numberAACFrames] = header3[numberAACFrames];
+    this[profile] = header3[profile];
+    this[protection] = header3[protection];
+  }
+  get audioSpecificConfig() {
+    const header3 = headerStore.get(this);
+    const audioSpecificConfig = header3[profileBits] + 64 << 5 | header3[sampleRateBits] << 5 | header3[channelModeBits] >> 3;
+    const bytes = new uint8Array(2);
+    new dataView(bytes[buffer]).setUint16(0, audioSpecificConfig, false);
+    return bytes;
+  }
+};
+
+// ../../node_modules/codec-parser/src/codecs/aac/AACFrame.js
+var AACFrame = class _AACFrame extends CodecFrame {
+  static *[getFrame](codecParser, headerCache, readOffset) {
+    return yield* super[getFrame](
+      AACHeader,
+      _AACFrame,
+      codecParser,
+      headerCache,
+      readOffset
+    );
+  }
+  constructor(header3, frame2, samples2) {
+    super(header3, frame2, samples2);
+  }
+};
+
+// ../../node_modules/codec-parser/src/codecs/aac/AACParser.js
+var AACParser = class extends Parser {
+  constructor(codecParser, headerCache, onCodec) {
+    super(codecParser, headerCache);
+    this.Frame = AACFrame;
+    this.Header = AACHeader;
+    onCodec(this[codec]);
+  }
+  get [codec]() {
+    return "aac";
+  }
+  *[parseFrame]() {
+    return yield* this[fixedLengthFrameSync]();
+  }
+};
+
+// ../../node_modules/codec-parser/src/codecs/flac/FLACFrame.js
+var FLACFrame = class _FLACFrame extends CodecFrame {
+  static _getFrameFooterCrc16(data3) {
+    return (data3[data3[length] - 2] << 8) + data3[data3[length] - 1];
+  }
+  // check frame footer crc
+  // https://xiph.org/flac/format.html#frame_footer
+  static [checkFrameFooterCrc16](data3) {
+    const expectedCrc16 = _FLACFrame._getFrameFooterCrc16(data3);
+    const actualCrc16 = flacCrc16(data3[subarray](0, -2));
+    return expectedCrc16 === actualCrc16;
+  }
+  constructor(data3, header3, streamInfoValue) {
+    header3[streamInfo] = streamInfoValue;
+    header3[crc16] = _FLACFrame._getFrameFooterCrc16(data3);
+    super(header3, data3, headerStore.get(header3)[samples]);
+  }
+};
+
+// ../../node_modules/codec-parser/src/codecs/flac/FLACHeader.js
+var getFromStreamInfo = "get from STREAMINFO metadata block";
+var blockingStrategyValues = {
+  0: "Fixed",
+  1: "Variable"
+};
+var blockSizeValues = {
+  0: reserved,
+  16: 192
+  // 0b00100000: 576,
+  // 0b00110000: 1152,
+  // 0b01000000: 2304,
+  // 0b01010000: 4608,
+  // 0b01100000: "8-bit (blocksize-1) from end of header",
+  // 0b01110000: "16-bit (blocksize-1) from end of header",
+  // 0b10000000: 256,
+  // 0b10010000: 512,
+  // 0b10100000: 1024,
+  // 0b10110000: 2048,
+  // 0b11000000: 4096,
+  // 0b11010000: 8192,
+  // 0b11100000: 16384,
+  // 0b11110000: 32768,
+};
+for (let i = 2; i < 16; i++)
+  blockSizeValues[i << 4] = i < 6 ? 576 * 2 ** (i - 2) : 2 ** i;
+var sampleRateValues = {
+  0: getFromStreamInfo,
+  1: rate88200,
+  2: rate176400,
+  3: rate192000,
+  4: rate8000,
+  5: rate16000,
+  6: rate22050,
+  7: rate24000,
+  8: rate32000,
+  9: rate44100,
+  10: rate48000,
+  11: rate96000,
+  // 0b00001100: "8-bit sample rate (in kHz) from end of header",
+  // 0b00001101: "16-bit sample rate (in Hz) from end of header",
+  // 0b00001110: "16-bit sample rate (in tens of Hz) from end of header",
+  15: bad
+};
+var channelAssignments = {
+  /*'
+  'monophonic (mono)'
+  'stereo (left, right)'
+  'linear surround (left, right, center)'
+  'quadraphonic (front left, front right, rear left, rear right)'
+  '5.0 surround (front left, front right, front center, rear left, rear right)'
+  '5.1 surround (front left, front right, front center, LFE, rear left, rear right)'
+  '6.1 surround (front left, front right, front center, LFE, rear center, side left, side right)'
+  '7.1 surround (front left, front right, front center, LFE, rear left, rear right, side left, side right)'
+  */
+  0: { [channels]: 1, [description]: monophonic },
+  16: { [channels]: 2, [description]: getChannelMapping(2, channelMappings[0][0]) },
+  32: { [channels]: 3, [description]: getChannelMapping(3, channelMappings[0][1]) },
+  48: { [channels]: 4, [description]: getChannelMapping(4, channelMappings[1][0], channelMappings[3][0]) },
+  64: { [channels]: 5, [description]: getChannelMapping(5, channelMappings[1][1], channelMappings[3][0]) },
+  80: { [channels]: 6, [description]: getChannelMapping(6, channelMappings[1][1], lfe, channelMappings[3][0]) },
+  96: { [channels]: 7, [description]: getChannelMapping(7, channelMappings[1][1], lfe, channelMappings[3][4], channelMappings[2][0]) },
+  112: { [channels]: 8, [description]: getChannelMapping(8, channelMappings[1][1], lfe, channelMappings[3][0], channelMappings[2][0]) },
+  128: { [channels]: 2, [description]: `${stereo} (left, diff)` },
+  144: { [channels]: 2, [description]: `${stereo} (diff, right)` },
+  160: { [channels]: 2, [description]: `${stereo} (avg, diff)` },
+  176: reserved,
+  192: reserved,
+  208: reserved,
+  224: reserved,
+  240: reserved
+};
+var bitDepthValues = {
+  0: getFromStreamInfo,
+  2: 8,
+  4: 12,
+  6: reserved,
+  8: 16,
+  10: 20,
+  12: 24,
+  14: reserved
+};
+var FLACHeader = class _FLACHeader extends CodecHeader {
+  // https://datatracker.ietf.org/doc/html/rfc3629#section-3
+  //    Char. number range  |        UTF-8 octet sequence
+  //    (hexadecimal)    |              (binary)
+  // --------------------+---------------------------------------------
+  // 0000 0000-0000 007F | 0xxxxxxx
+  // 0000 0080-0000 07FF | 110xxxxx 10xxxxxx
+  // 0000 0800-0000 FFFF | 1110xxxx 10xxxxxx 10xxxxxx
+  // 0001 0000-0010 FFFF | 11110xxx 10xxxxxx 10xxxxxx 10xxxxxx
+  static _decodeUTF8Int(data3) {
+    if (data3[0] > 254) {
+      return null;
+    }
+    if (data3[0] < 128) return { value: data3[0], length: 1 };
+    let length2 = 1;
+    for (let zeroMask = 64; zeroMask & data3[0]; zeroMask >>= 1) length2++;
+    let idx = length2 - 1, value = 0, shift = 0;
+    for (; idx > 0; shift += 6, idx--) {
+      if ((data3[idx] & 192) !== 128) {
+        return null;
+      }
+      value |= (data3[idx] & 63) << shift;
+    }
+    value |= (data3[idx] & 127 >> length2) << shift;
+    return { value, length: length2 };
+  }
+  static [getHeaderFromUint8Array](data3, headerCache) {
+    const codecParserStub = {
+      [readRawData]: function* () {
+        return data3;
+      }
+    };
+    return _FLACHeader[getHeader](codecParserStub, headerCache, 0).next().value;
+  }
+  static *[getHeader](codecParser, headerCache, readOffset) {
+    let data3 = yield* codecParser[readRawData](6, readOffset);
+    if (data3[0] !== 255 || !(data3[1] === 248 || data3[1] === 249)) {
+      return null;
+    }
+    const header3 = {};
+    const key = bytesToString(data3[subarray](0, 4));
+    const cachedHeader = headerCache[getHeader](key);
+    if (!cachedHeader) {
+      header3[blockingStrategyBits] = data3[1] & 1;
+      header3[blockingStrategy] = blockingStrategyValues[header3[blockingStrategyBits]];
+      header3[blockSizeBits] = data3[2] & 240;
+      header3[sampleRateBits] = data3[2] & 15;
+      header3[blockSize] = blockSizeValues[header3[blockSizeBits]];
+      if (header3[blockSize] === reserved) {
+        return null;
+      }
+      header3[sampleRate] = sampleRateValues[header3[sampleRateBits]];
+      if (header3[sampleRate] === bad) {
+        return null;
+      }
+      if (data3[3] & 1) {
+        return null;
+      }
+      const channelAssignment = channelAssignments[data3[3] & 240];
+      if (channelAssignment === reserved) {
+        return null;
+      }
+      header3[channels] = channelAssignment[channels];
+      header3[channelMode] = channelAssignment[description];
+      header3[bitDepth] = bitDepthValues[data3[3] & 14];
+      if (header3[bitDepth] === reserved) {
+        return null;
+      }
+    } else {
+      Object.assign(header3, cachedHeader);
+    }
+    header3[length] = 5;
+    data3 = yield* codecParser[readRawData](header3[length] + 8, readOffset);
+    const decodedUtf8 = _FLACHeader._decodeUTF8Int(data3[subarray](4));
+    if (!decodedUtf8) {
+      return null;
+    }
+    if (header3[blockingStrategyBits]) {
+      header3[sampleNumber] = decodedUtf8.value;
+    } else {
+      header3[frameNumber] = decodedUtf8.value;
+    }
+    header3[length] += decodedUtf8[length];
+    if (header3[blockSizeBits] === 96) {
+      if (data3[length] < header3[length])
+        data3 = yield* codecParser[readRawData](header3[length], readOffset);
+      header3[blockSize] = data3[header3[length] - 1] + 1;
+      header3[length] += 1;
+    } else if (header3[blockSizeBits] === 112) {
+      if (data3[length] < header3[length])
+        data3 = yield* codecParser[readRawData](header3[length], readOffset);
+      header3[blockSize] = (data3[header3[length] - 1] << 8) + data3[header3[length]] + 1;
+      header3[length] += 2;
+    }
+    header3[samples] = header3[blockSize];
+    if (header3[sampleRateBits] === 12) {
+      if (data3[length] < header3[length])
+        data3 = yield* codecParser[readRawData](header3[length], readOffset);
+      header3[sampleRate] = data3[header3[length] - 1] * 1e3;
+      header3[length] += 1;
+    } else if (header3[sampleRateBits] === 13) {
+      if (data3[length] < header3[length])
+        data3 = yield* codecParser[readRawData](header3[length], readOffset);
+      header3[sampleRate] = (data3[header3[length] - 1] << 8) + data3[header3[length]];
+      header3[length] += 2;
+    } else if (header3[sampleRateBits] === 14) {
+      if (data3[length] < header3[length])
+        data3 = yield* codecParser[readRawData](header3[length], readOffset);
+      header3[sampleRate] = ((data3[header3[length] - 1] << 8) + data3[header3[length]]) * 10;
+      header3[length] += 2;
+    }
+    if (data3[length] < header3[length])
+      data3 = yield* codecParser[readRawData](header3[length], readOffset);
+    header3[crc] = data3[header3[length] - 1];
+    if (header3[crc] !== crc8(data3[subarray](0, header3[length] - 1))) {
+      return null;
+    }
+    {
+      if (!cachedHeader) {
+        const {
+          blockingStrategyBits: blockingStrategyBits2,
+          frameNumber: frameNumber2,
+          sampleNumber: sampleNumber2,
+          samples: samples2,
+          sampleRateBits: sampleRateBits2,
+          blockSizeBits: blockSizeBits2,
+          crc: crc2,
+          length: length2,
+          ...codecUpdateFields
+        } = header3;
+        headerCache[setHeader](key, header3, codecUpdateFields);
+      }
+    }
+    return new _FLACHeader(header3);
+  }
+  /**
+   * @private
+   * Call FLACHeader.getHeader(Array<Uint8>) to get instance
+   */
+  constructor(header3) {
+    super(header3);
+    this[crc16] = null;
+    this[blockingStrategy] = header3[blockingStrategy];
+    this[blockSize] = header3[blockSize];
+    this[frameNumber] = header3[frameNumber];
+    this[sampleNumber] = header3[sampleNumber];
+    this[streamInfo] = null;
+  }
+};
+
+// ../../node_modules/codec-parser/src/codecs/flac/FLACParser.js
+var MIN_FLAC_FRAME_SIZE = 2;
+var MAX_FLAC_FRAME_SIZE = 512 * 1024;
+var FLACParser = class extends Parser {
+  constructor(codecParser, headerCache, onCodec) {
+    super(codecParser, headerCache);
+    this.Frame = FLACFrame;
+    this.Header = FLACHeader;
+    onCodec(this[codec]);
+  }
+  get [codec]() {
+    return "flac";
+  }
+  *_getNextFrameSyncOffset(offset) {
+    const data3 = yield* this._codecParser[readRawData](2, 0);
+    const dataLength = data3[length] - 2;
+    while (offset < dataLength) {
+      const firstByte = data3[offset];
+      if (firstByte === 255) {
+        const secondByte = data3[offset + 1];
+        if (secondByte === 248 || secondByte === 249) break;
+        if (secondByte !== 255) offset++;
+      }
+      offset++;
+    }
+    return offset;
+  }
+  *[parseFrame]() {
+    do {
+      const header3 = yield* FLACHeader[getHeader](
+        this._codecParser,
+        this._headerCache,
+        0
+      );
+      if (header3) {
+        let nextHeaderOffset = headerStore.get(header3)[length] + MIN_FLAC_FRAME_SIZE;
+        while (nextHeaderOffset <= MAX_FLAC_FRAME_SIZE) {
+          if (this._codecParser._flushing || (yield* FLACHeader[getHeader](
+            this._codecParser,
+            this._headerCache,
+            nextHeaderOffset
+          ))) {
+            let frameData = yield* this._codecParser[readRawData](nextHeaderOffset);
+            if (!this._codecParser._flushing)
+              frameData = frameData[subarray](0, nextHeaderOffset);
+            if (FLACFrame[checkFrameFooterCrc16](frameData)) {
+              const frame2 = new FLACFrame(frameData, header3);
+              this._headerCache[enable]();
+              this._codecParser[incrementRawData](nextHeaderOffset);
+              this._codecParser[mapFrameStats](frame2);
+              return frame2;
+            }
+          }
+          nextHeaderOffset = yield* this._getNextFrameSyncOffset(
+            nextHeaderOffset + 1
+          );
+        }
+        this._codecParser[logWarning](
+          `Unable to sync FLAC frame after searching ${nextHeaderOffset} bytes.`
+        );
+        this._codecParser[incrementRawData](nextHeaderOffset);
+      } else {
+        this._codecParser[incrementRawData](
+          yield* this._getNextFrameSyncOffset(1)
+        );
+      }
+    } while (true);
+  }
+  [parseOggPage](oggPage) {
+    if (oggPage[pageSequenceNumber] === 0) {
+      this._headerCache[enable]();
+      this._streamInfo = oggPage[data][subarray](13);
+    } else if (oggPage[pageSequenceNumber] === 1) {
+    } else {
+      oggPage[codecFrames] = frameStore.get(oggPage)[segments].map((segment) => {
+        const header3 = FLACHeader[getHeaderFromUint8Array](
+          segment,
+          this._headerCache
+        );
+        if (header3) {
+          return new FLACFrame(segment, header3, this._streamInfo);
+        } else {
+          this._codecParser[logWarning](
+            "Failed to parse Ogg FLAC frame",
+            "Skipping invalid FLAC frame"
+          );
+        }
+      }).filter((frame2) => !!frame2);
+    }
+    return oggPage;
+  }
+};
+
+// ../../node_modules/codec-parser/src/containers/ogg/OggPageHeader.js
+var OggPageHeader = class _OggPageHeader {
+  static *[getHeader](codecParser, headerCache, readOffset) {
+    const header3 = {};
+    let data3 = yield* codecParser[readRawData](28, readOffset);
+    if (data3[0] !== 79 || // O
+    data3[1] !== 103 || // g
+    data3[2] !== 103 || // g
+    data3[3] !== 83) {
+      return null;
+    }
+    header3[streamStructureVersion] = data3[4];
+    const zeros = data3[5] & 248;
+    if (zeros) return null;
+    header3[isLastPage] = !!(data3[5] & 4);
+    header3[isFirstPage] = !!(data3[5] & 2);
+    header3[isContinuedPacket] = !!(data3[5] & 1);
+    const view = new dataView(uint8Array.from(data3[subarray](0, 28))[buffer]);
+    header3[absoluteGranulePosition] = readInt64le(view, 6);
+    header3[streamSerialNumber] = view.getInt32(14, true);
+    header3[pageSequenceNumber] = view.getInt32(18, true);
+    header3[pageChecksum] = view.getInt32(22, true);
+    const pageSegmentTableLength = data3[26];
+    header3[length] = pageSegmentTableLength + 27;
+    data3 = yield* codecParser[readRawData](header3[length], readOffset);
+    header3[frameLength] = 0;
+    header3[pageSegmentTable] = [];
+    header3[pageSegmentBytes] = uint8Array.from(
+      data3[subarray](27, header3[length])
+    );
+    for (let i = 0, segmentLength = 0; i < pageSegmentTableLength; i++) {
+      const segmentByte = header3[pageSegmentBytes][i];
+      header3[frameLength] += segmentByte;
+      segmentLength += segmentByte;
+      if (segmentByte !== 255 || i === pageSegmentTableLength - 1) {
+        header3[pageSegmentTable].push(segmentLength);
+        segmentLength = 0;
+      }
+    }
+    return new _OggPageHeader(header3);
+  }
+  /**
+   * @private
+   * Call OggPageHeader.getHeader(Array<Uint8>) to get instance
+   */
+  constructor(header3) {
+    headerStore.set(this, header3);
+    this[absoluteGranulePosition] = header3[absoluteGranulePosition];
+    this[isContinuedPacket] = header3[isContinuedPacket];
+    this[isFirstPage] = header3[isFirstPage];
+    this[isLastPage] = header3[isLastPage];
+    this[pageSegmentTable] = header3[pageSegmentTable];
+    this[pageSequenceNumber] = header3[pageSequenceNumber];
+    this[pageChecksum] = header3[pageChecksum];
+    this[streamSerialNumber] = header3[streamSerialNumber];
+  }
+};
+
+// ../../node_modules/codec-parser/src/containers/ogg/OggPage.js
+var OggPage = class _OggPage extends Frame {
+  static *[getFrame](codecParser, headerCache, readOffset) {
+    const header3 = yield* OggPageHeader[getHeader](
+      codecParser,
+      headerCache,
+      readOffset
+    );
+    if (header3) {
+      const frameLengthValue = headerStore.get(header3)[frameLength];
+      const headerLength = headerStore.get(header3)[length];
+      const totalLength = headerLength + frameLengthValue;
+      const rawDataValue = (yield* codecParser[readRawData](totalLength, 0))[subarray](0, totalLength);
+      const frame2 = rawDataValue[subarray](headerLength, totalLength);
+      return new _OggPage(header3, frame2, rawDataValue);
+    } else {
+      return null;
+    }
+  }
+  constructor(header3, frame2, rawDataValue) {
+    super(header3, frame2);
+    frameStore.get(this)[length] = rawDataValue[length];
+    this[codecFrames] = [];
+    this[rawData] = rawDataValue;
+    this[absoluteGranulePosition] = header3[absoluteGranulePosition];
+    this[crc32] = header3[pageChecksum];
+    this[duration] = 0;
+    this[isContinuedPacket] = header3[isContinuedPacket];
+    this[isFirstPage] = header3[isFirstPage];
+    this[isLastPage] = header3[isLastPage];
+    this[pageSequenceNumber] = header3[pageSequenceNumber];
+    this[samples] = 0;
+    this[streamSerialNumber] = header3[streamSerialNumber];
+  }
+};
+
+// ../../node_modules/codec-parser/src/codecs/opus/OpusFrame.js
+var OpusFrame = class extends CodecFrame {
+  constructor(data3, header3, samples2) {
+    super(header3, data3, samples2);
+  }
+};
+
+// ../../node_modules/codec-parser/src/codecs/opus/OpusHeader.js
+var channelMappingFamilies = {
+  0: vorbisOpusChannelMapping.slice(0, 2),
+  /*
+  0: "monophonic (mono)"
+  1: "stereo (left, right)"
+  */
+  1: vorbisOpusChannelMapping
+  /*
+  0: "monophonic (mono)"
+  1: "stereo (left, right)"
+  2: "linear surround (left, center, right)"
+  3: "quadraphonic (front left, front right, rear left, rear right)"
+  4: "5.0 surround (front left, front center, front right, rear left, rear right)"
+  5: "5.1 surround (front left, front center, front right, rear left, rear right, LFE)"
+  6: "6.1 surround (front left, front center, front right, side left, side right, rear center, LFE)"
+  7: "7.1 surround (front left, front center, front right, side left, side right, rear left, rear right, LFE)"
+  */
+  // additional channel mappings are user defined
+};
+var silkOnly = "SILK-only";
+var celtOnly = "CELT-only";
+var hybrid = "Hybrid";
+var narrowBand = "narrowband";
+var mediumBand = "medium-band";
+var wideBand = "wideband";
+var superWideBand = "super-wideband";
+var fullBand = "fullband";
+var configTable = {
+  0: { [mode]: silkOnly, [bandwidth]: narrowBand, [frameSize]: 10 },
+  8: { [mode]: silkOnly, [bandwidth]: narrowBand, [frameSize]: 20 },
+  16: { [mode]: silkOnly, [bandwidth]: narrowBand, [frameSize]: 40 },
+  24: { [mode]: silkOnly, [bandwidth]: narrowBand, [frameSize]: 60 },
+  32: { [mode]: silkOnly, [bandwidth]: mediumBand, [frameSize]: 10 },
+  40: { [mode]: silkOnly, [bandwidth]: mediumBand, [frameSize]: 20 },
+  48: { [mode]: silkOnly, [bandwidth]: mediumBand, [frameSize]: 40 },
+  56: { [mode]: silkOnly, [bandwidth]: mediumBand, [frameSize]: 60 },
+  64: { [mode]: silkOnly, [bandwidth]: wideBand, [frameSize]: 10 },
+  72: { [mode]: silkOnly, [bandwidth]: wideBand, [frameSize]: 20 },
+  80: { [mode]: silkOnly, [bandwidth]: wideBand, [frameSize]: 40 },
+  88: { [mode]: silkOnly, [bandwidth]: wideBand, [frameSize]: 60 },
+  96: { [mode]: hybrid, [bandwidth]: superWideBand, [frameSize]: 10 },
+  104: { [mode]: hybrid, [bandwidth]: superWideBand, [frameSize]: 20 },
+  112: { [mode]: hybrid, [bandwidth]: fullBand, [frameSize]: 10 },
+  120: { [mode]: hybrid, [bandwidth]: fullBand, [frameSize]: 20 },
+  128: { [mode]: celtOnly, [bandwidth]: narrowBand, [frameSize]: 2.5 },
+  136: { [mode]: celtOnly, [bandwidth]: narrowBand, [frameSize]: 5 },
+  144: { [mode]: celtOnly, [bandwidth]: narrowBand, [frameSize]: 10 },
+  152: { [mode]: celtOnly, [bandwidth]: narrowBand, [frameSize]: 20 },
+  160: { [mode]: celtOnly, [bandwidth]: wideBand, [frameSize]: 2.5 },
+  168: { [mode]: celtOnly, [bandwidth]: wideBand, [frameSize]: 5 },
+  176: { [mode]: celtOnly, [bandwidth]: wideBand, [frameSize]: 10 },
+  184: { [mode]: celtOnly, [bandwidth]: wideBand, [frameSize]: 20 },
+  192: { [mode]: celtOnly, [bandwidth]: superWideBand, [frameSize]: 2.5 },
+  200: { [mode]: celtOnly, [bandwidth]: superWideBand, [frameSize]: 5 },
+  208: { [mode]: celtOnly, [bandwidth]: superWideBand, [frameSize]: 10 },
+  216: { [mode]: celtOnly, [bandwidth]: superWideBand, [frameSize]: 20 },
+  224: { [mode]: celtOnly, [bandwidth]: fullBand, [frameSize]: 2.5 },
+  232: { [mode]: celtOnly, [bandwidth]: fullBand, [frameSize]: 5 },
+  240: { [mode]: celtOnly, [bandwidth]: fullBand, [frameSize]: 10 },
+  248: { [mode]: celtOnly, [bandwidth]: fullBand, [frameSize]: 20 }
+};
+var OpusHeader = class _OpusHeader extends CodecHeader {
+  static [getHeaderFromUint8Array](dataValue, packetData, headerCache) {
+    const header3 = {};
+    header3[channels] = dataValue[9];
+    header3[channelMappingFamily] = dataValue[18];
+    header3[length] = header3[channelMappingFamily] !== 0 ? 21 + header3[channels] : 19;
+    if (dataValue[length] < header3[length])
+      throw new Error("Out of data while inside an Ogg Page");
+    const packetMode = packetData[0] & 3;
+    const packetLength = packetMode === 3 ? 2 : 1;
+    const key = bytesToString(dataValue[subarray](0, header3[length])) + bytesToString(packetData[subarray](0, packetLength));
+    const cachedHeader = headerCache[getHeader](key);
+    if (cachedHeader) return new _OpusHeader(cachedHeader);
+    if (key.substr(0, 8) !== "OpusHead") {
+      return null;
+    }
+    if (dataValue[8] !== 1) return null;
+    header3[data] = uint8Array.from(dataValue[subarray](0, header3[length]));
+    const view = new dataView(header3[data][buffer]);
+    header3[bitDepth] = 16;
+    header3[preSkip] = view.getUint16(10, true);
+    header3[inputSampleRate] = view.getUint32(12, true);
+    header3[sampleRate] = rate48000;
+    header3[outputGain] = view.getInt16(16, true);
+    if (header3[channelMappingFamily] in channelMappingFamilies) {
+      header3[channelMode] = channelMappingFamilies[header3[channelMappingFamily]][header3[channels] - 1];
+      if (!header3[channelMode]) return null;
+    }
+    if (header3[channelMappingFamily] !== 0) {
+      header3[streamCount] = dataValue[19];
+      header3[coupledStreamCount] = dataValue[20];
+      header3[channelMappingTable] = [
+        ...dataValue[subarray](21, header3[channels] + 21)
+      ];
+    }
+    const packetConfig = configTable[248 & packetData[0]];
+    header3[mode] = packetConfig[mode];
+    header3[bandwidth] = packetConfig[bandwidth];
+    header3[frameSize] = packetConfig[frameSize];
+    switch (packetMode) {
+      case 0:
+        header3[frameCount] = 1;
+        break;
+      case 1:
+      // 1: 2 frames in the packet, each with equal compressed size
+      case 2:
+        header3[frameCount] = 2;
+        break;
+      case 3:
+        header3[isVbr] = !!(128 & packetData[1]);
+        header3[hasOpusPadding] = !!(64 & packetData[1]);
+        header3[frameCount] = 63 & packetData[1];
+        break;
+      default:
+        return null;
+    }
+    {
+      const {
+        length: length2,
+        data: headerData,
+        channelMappingFamily: channelMappingFamily2,
+        ...codecUpdateFields
+      } = header3;
+      headerCache[setHeader](key, header3, codecUpdateFields);
+    }
+    return new _OpusHeader(header3);
+  }
+  /**
+   * @private
+   * Call OpusHeader.getHeader(Array<Uint8>) to get instance
+   */
+  constructor(header3) {
+    super(header3);
+    this[data] = header3[data];
+    this[bandwidth] = header3[bandwidth];
+    this[channelMappingFamily] = header3[channelMappingFamily];
+    this[channelMappingTable] = header3[channelMappingTable];
+    this[coupledStreamCount] = header3[coupledStreamCount];
+    this[frameCount] = header3[frameCount];
+    this[frameSize] = header3[frameSize];
+    this[hasOpusPadding] = header3[hasOpusPadding];
+    this[inputSampleRate] = header3[inputSampleRate];
+    this[isVbr] = header3[isVbr];
+    this[mode] = header3[mode];
+    this[outputGain] = header3[outputGain];
+    this[preSkip] = header3[preSkip];
+    this[streamCount] = header3[streamCount];
+  }
+};
+
+// ../../node_modules/codec-parser/src/codecs/opus/OpusParser.js
+var OpusParser = class extends Parser {
+  constructor(codecParser, headerCache, onCodec) {
+    super(codecParser, headerCache);
+    this.Frame = OpusFrame;
+    this.Header = OpusHeader;
+    onCodec(this[codec]);
+    this._identificationHeader = null;
+    this._preSkipRemaining = null;
+  }
+  get [codec]() {
+    return "opus";
+  }
+  /**
+   * @todo implement continued page support
+   */
+  [parseOggPage](oggPage) {
+    if (oggPage[pageSequenceNumber] === 0) {
+      this._headerCache[enable]();
+      this._identificationHeader = oggPage[data];
+    } else if (oggPage[pageSequenceNumber] === 1) {
+    } else {
+      oggPage[codecFrames] = frameStore.get(oggPage)[segments].map((segment) => {
+        const header3 = OpusHeader[getHeaderFromUint8Array](
+          this._identificationHeader,
+          segment,
+          this._headerCache
+        );
+        if (header3) {
+          if (this._preSkipRemaining === null)
+            this._preSkipRemaining = header3[preSkip];
+          let samples2 = header3[frameSize] * header3[frameCount] / 1e3 * header3[sampleRate];
+          if (this._preSkipRemaining > 0) {
+            this._preSkipRemaining -= samples2;
+            samples2 = this._preSkipRemaining < 0 ? -this._preSkipRemaining : 0;
+          }
+          return new OpusFrame(segment, header3, samples2);
+        }
+        this._codecParser[logError2](
+          "Failed to parse Ogg Opus Header",
+          "Not a valid Ogg Opus file"
+        );
+      });
+    }
+    return oggPage;
+  }
+};
+
+// ../../node_modules/codec-parser/src/codecs/vorbis/VorbisFrame.js
+var VorbisFrame = class extends CodecFrame {
+  constructor(data3, header3, samples2) {
+    super(header3, data3, samples2);
+  }
+};
+
+// ../../node_modules/codec-parser/src/codecs/vorbis/VorbisHeader.js
+var blockSizes = {
+  // 0b0110: 64,
+  // 0b0111: 128,
+  // 0b1000: 256,
+  // 0b1001: 512,
+  // 0b1010: 1024,
+  // 0b1011: 2048,
+  // 0b1100: 4096,
+  // 0b1101: 8192
+};
+for (let i = 0; i < 8; i++) blockSizes[i + 6] = 2 ** (6 + i);
+var VorbisHeader = class _VorbisHeader extends CodecHeader {
+  static [getHeaderFromUint8Array](dataValue, headerCache, vorbisCommentsData, vorbisSetupData) {
+    if (dataValue[length] < 30)
+      throw new Error("Out of data while inside an Ogg Page");
+    const key = bytesToString(dataValue[subarray](0, 30));
+    const cachedHeader = headerCache[getHeader](key);
+    if (cachedHeader) return new _VorbisHeader(cachedHeader);
+    const header3 = { [length]: 30 };
+    if (key.substr(0, 7) !== "
vorbis") {
+      return null;
+    }
+    header3[data] = uint8Array.from(dataValue[subarray](0, 30));
+    const view = new dataView(header3[data][buffer]);
+    header3[version] = view.getUint32(7, true);
+    if (header3[version] !== 0) return null;
+    header3[channels] = dataValue[11];
+    header3[channelMode] = vorbisOpusChannelMapping[header3[channels] - 1] || "application defined";
+    header3[sampleRate] = view.getUint32(12, true);
+    header3[bitrateMaximum] = view.getInt32(16, true);
+    header3[bitrateNominal] = view.getInt32(20, true);
+    header3[bitrateMinimum] = view.getInt32(24, true);
+    header3[blocksize1] = blockSizes[(dataValue[28] & 240) >> 4];
+    header3[blocksize0] = blockSizes[dataValue[28] & 15];
+    if (header3[blocksize0] > header3[blocksize1]) return null;
+    if (dataValue[29] !== 1) return null;
+    header3[bitDepth] = 32;
+    header3[vorbisSetup] = vorbisSetupData;
+    header3[vorbisComments] = vorbisCommentsData;
+    {
+      const {
+        length: length2,
+        data: data3,
+        version: version2,
+        vorbisSetup: vorbisSetup3,
+        vorbisComments: vorbisComments3,
+        ...codecUpdateFields
+      } = header3;
+      headerCache[setHeader](key, header3, codecUpdateFields);
+    }
+    return new _VorbisHeader(header3);
+  }
+  /**
+   * @private
+   * Call VorbisHeader.getHeader(Array<Uint8>) to get instance
+   */
+  constructor(header3) {
+    super(header3);
+    this[bitrateMaximum] = header3[bitrateMaximum];
+    this[bitrateMinimum] = header3[bitrateMinimum];
+    this[bitrateNominal] = header3[bitrateNominal];
+    this[blocksize0] = header3[blocksize0];
+    this[blocksize1] = header3[blocksize1];
+    this[data] = header3[data];
+    this[vorbisComments] = header3[vorbisComments];
+    this[vorbisSetup] = header3[vorbisSetup];
+  }
+};
+
+// ../../node_modules/codec-parser/src/codecs/vorbis/VorbisParser.js
+var VorbisParser = class extends Parser {
+  constructor(codecParser, headerCache, onCodec) {
+    super(codecParser, headerCache);
+    this.Frame = VorbisFrame;
+    onCodec(this[codec]);
+    this._identificationHeader = null;
+    this._setupComplete = false;
+    this._prevBlockSize = null;
+  }
+  get [codec]() {
+    return vorbis;
+  }
+  [parseOggPage](oggPage) {
+    oggPage[codecFrames] = [];
+    for (const oggPageSegment of frameStore.get(oggPage)[segments]) {
+      if (oggPageSegment[0] === 1) {
+        this._headerCache[enable]();
+        this._identificationHeader = oggPage[data];
+        this._setupComplete = false;
+      } else if (oggPageSegment[0] === 3) {
+        this._vorbisComments = oggPageSegment;
+      } else if (oggPageSegment[0] === 5) {
+        this._vorbisSetup = oggPageSegment;
+        this._mode = this._parseSetupHeader(oggPageSegment);
+        this._setupComplete = true;
+      } else if (this._setupComplete) {
+        const header3 = VorbisHeader[getHeaderFromUint8Array](
+          this._identificationHeader,
+          this._headerCache,
+          this._vorbisComments,
+          this._vorbisSetup
+        );
+        if (header3) {
+          oggPage[codecFrames].push(
+            new VorbisFrame(
+              oggPageSegment,
+              header3,
+              this._getSamples(oggPageSegment, header3)
+            )
+          );
+        } else {
+          this._codecParser[logError](
+            "Failed to parse Ogg Vorbis Header",
+            "Not a valid Ogg Vorbis file"
+          );
+        }
+      }
+    }
+    return oggPage;
+  }
+  _getSamples(segment, header3) {
+    const blockFlag = this._mode.blockFlags[segment[0] >> 1 & this._mode.mask];
+    const currentBlockSize = blockFlag ? header3[blocksize1] : header3[blocksize0];
+    const samplesValue = this._prevBlockSize === null ? 0 : (this._prevBlockSize + currentBlockSize) / 4;
+    this._prevBlockSize = currentBlockSize;
+    return samplesValue;
+  }
+  // https://gitlab.xiph.org/xiph/liboggz/-/blob/master/src/liboggz/oggz_auto.c#L911
+  // https://github.com/FFmpeg/FFmpeg/blob/master/libavcodec/vorbis_parser.c
+  /*
+   * This is the format of the mode data at the end of the packet for all
+   * Vorbis Version 1 :
+   *
+   * [ 6:number_of_modes ]
+   * [ 1:size | 16:window_type(0) | 16:transform_type(0) | 8:mapping ]
+   * [ 1:size | 16:window_type(0) | 16:transform_type(0) | 8:mapping ]
+   * [ 1:size | 16:window_type(0) | 16:transform_type(0) | 8:mapping ]
+   * [ 1:framing(1) ]
+   *
+   * e.g.:
+   *
+   * MsB         LsB
+   *              <-
+   * 0 0 0 0 0 1 0 0
+   * 0 0 1 0 0 0 0 0
+   * 0 0 1 0 0 0 0 0
+   * 0 0 1|0 0 0 0 0
+   * 0 0 0 0|0|0 0 0
+   * 0 0 0 0 0 0 0 0
+   * 0 0 0 0|0 0 0 0
+   * 0 0 0 0 0 0 0 0
+   * 0 0 0 0|0 0 0 0
+   * 0 0 0|1|0 0 0 0 |
+   * 0 0 0 0 0 0 0 0 V
+   * 0 0 0|0 0 0 0 0
+   * 0 0 0 0 0 0 0 0
+   * 0 0|1 0 0 0 0 0
+   *
+   * The simplest way to approach this is to start at the end
+   * and read backwards to determine the mode configuration.
+   *
+   * liboggz and ffmpeg both use this method.
+   */
+  _parseSetupHeader(setup) {
+    const bitReader = new BitReader(setup);
+    const mode2 = {
+      count: 0,
+      blockFlags: []
+    };
+    while ((bitReader.read(1) & 1) !== 1) {
+    }
+    let modeBits;
+    while (mode2.count < 64 && bitReader.position > 0) {
+      reverse(bitReader.read(8));
+      let currentByte = 0;
+      while (bitReader.read(8) === 0 && currentByte++ < 3) {
+      }
+      if (currentByte === 4) {
+        modeBits = bitReader.read(7);
+        mode2.blockFlags.unshift(modeBits & 1);
+        bitReader.position += 6;
+        mode2.count++;
+      } else {
+        if (((reverse(modeBits) & 126) >> 1) + 1 !== mode2.count) {
+          this._codecParser[logWarning](
+            "vorbis derived mode count did not match actual mode count"
+          );
+        }
+        break;
+      }
+    }
+    mode2.mask = (1 << Math.log2(mode2.count)) - 1;
+    return mode2;
+  }
+};
+
+// ../../node_modules/codec-parser/src/containers/ogg/OggParser.js
+var OggStream = class {
+  constructor(codecParser, headerCache, onCodec) {
+    this._codecParser = codecParser;
+    this._headerCache = headerCache;
+    this._onCodec = onCodec;
+    this._continuedPacket = new uint8Array();
+    this._codec = null;
+    this._isSupported = null;
+    this._previousAbsoluteGranulePosition = null;
+  }
+  get [codec]() {
+    return this._codec || "";
+  }
+  _updateCodec(codec2, Parser2) {
+    if (this._codec !== codec2) {
+      this._headerCache[reset]();
+      this._parser = new Parser2(
+        this._codecParser,
+        this._headerCache,
+        this._onCodec
+      );
+      this._codec = codec2;
+    }
+  }
+  _checkCodecSupport({ data: data3 }) {
+    const idString = bytesToString(data3[subarray](0, 8));
+    switch (idString) {
+      case "fishead\0":
+        return false;
+      // ignore ogg skeleton packets
+      case "OpusHead":
+        this._updateCodec("opus", OpusParser);
+        return true;
+      case (/^\x7fFLAC/.test(idString) && idString):
+        this._updateCodec("flac", FLACParser);
+        return true;
+      case (/^\x01vorbis/.test(idString) && idString):
+        this._updateCodec(vorbis, VorbisParser);
+        return true;
+      default:
+        return false;
+    }
+  }
+  _checkPageSequenceNumber(oggPage) {
+    if (oggPage[pageSequenceNumber] !== this._pageSequenceNumber + 1 && this._pageSequenceNumber > 1 && oggPage[pageSequenceNumber] > 1) {
+      this._codecParser[logWarning](
+        "Unexpected gap in Ogg Page Sequence Number.",
+        `Expected: ${this._pageSequenceNumber + 1}, Got: ${oggPage[pageSequenceNumber]}`
+      );
+    }
+    this._pageSequenceNumber = oggPage[pageSequenceNumber];
+  }
+  _parsePage(oggPage) {
+    if (this._isSupported === null) {
+      this._pageSequenceNumber = oggPage[pageSequenceNumber];
+      this._isSupported = this._checkCodecSupport(oggPage);
+    }
+    this._checkPageSequenceNumber(oggPage);
+    const oggPageStore = frameStore.get(oggPage);
+    const headerData = headerStore.get(oggPageStore[header]);
+    let offset = 0;
+    oggPageStore[segments] = headerData[pageSegmentTable].map(
+      (segmentLength) => oggPage[data][subarray](offset, offset += segmentLength)
+    );
+    if (this._continuedPacket[length]) {
+      oggPageStore[segments][0] = concatBuffers(
+        this._continuedPacket,
+        oggPageStore[segments][0]
+      );
+      this._continuedPacket = new uint8Array();
+    }
+    if (headerData[pageSegmentBytes][headerData[pageSegmentBytes][length] - 1] === 255) {
+      this._continuedPacket = concatBuffers(
+        this._continuedPacket,
+        oggPageStore[segments].pop()
+      );
+    }
+    if (this._previousAbsoluteGranulePosition !== null) {
+      oggPage[samples] = Number(
+        oggPage[absoluteGranulePosition] - this._previousAbsoluteGranulePosition
+      );
+    }
+    this._previousAbsoluteGranulePosition = oggPage[absoluteGranulePosition];
+    if (this._isSupported) {
+      const frame2 = this._parser[parseOggPage](oggPage);
+      this._codecParser[mapFrameStats](frame2);
+      return frame2;
+    } else {
+      return oggPage;
+    }
+  }
+};
+var OggParser = class extends Parser {
+  constructor(codecParser, headerCache, onCodec) {
+    super(codecParser, headerCache);
+    this._onCodec = onCodec;
+    this.Frame = OggPage;
+    this.Header = OggPageHeader;
+    this._streams = /* @__PURE__ */ new Map();
+    this._currentSerialNumber = null;
+  }
+  get [codec]() {
+    const oggStream = this._streams.get(this._currentSerialNumber);
+    return oggStream ? oggStream.codec : "";
+  }
+  *[parseFrame]() {
+    const oggPage = yield* this[fixedLengthFrameSync](true);
+    this._currentSerialNumber = oggPage[streamSerialNumber];
+    let oggStream = this._streams.get(this._currentSerialNumber);
+    if (!oggStream) {
+      oggStream = new OggStream(
+        this._codecParser,
+        this._headerCache,
+        this._onCodec
+      );
+      this._streams.set(this._currentSerialNumber, oggStream);
+    }
+    if (oggPage[isLastPage]) this._streams.delete(this._currentSerialNumber);
+    return oggStream._parsePage(oggPage);
+  }
+};
+
+// ../../node_modules/codec-parser/src/CodecParser.js
+var noOp = () => {
+};
+var CodecParser = class {
+  constructor(mimeType2, {
+    onCodec,
+    onCodecHeader,
+    onCodecUpdate,
+    enableLogging = false,
+    enableFrameCRC32 = true
+  } = {}) {
+    this._inputMimeType = mimeType2;
+    this._onCodec = onCodec || noOp;
+    this._onCodecHeader = onCodecHeader || noOp;
+    this._onCodecUpdate = onCodecUpdate;
+    this._enableLogging = enableLogging;
+    this._crc32 = enableFrameCRC32 ? crc32Function : noOp;
+    this[reset]();
+  }
+  /**
+   * @public
+   * @returns The detected codec
+   */
+  get [codec]() {
+    return this._parser ? this._parser[codec] : "";
+  }
+  [reset]() {
+    this._headerCache = new HeaderCache(
+      this._onCodecHeader,
+      this._onCodecUpdate
+    );
+    this._generator = this._getGenerator();
+    this._generator.next();
+  }
+  /**
+   * @public
+   * @description Generator function that yields any buffered CodecFrames and resets the CodecParser
+   * @returns {Iterable<CodecFrame|OggPage>} Iterator that operates over the codec data.
+   * @yields {CodecFrame|OggPage} Parsed codec or ogg page data
+   */
+  *flush() {
+    this._flushing = true;
+    for (let i = this._generator.next(); i.value; i = this._generator.next()) {
+      yield i.value;
+    }
+    this._flushing = false;
+    this[reset]();
+  }
+  /**
+   * @public
+   * @description Generator function takes in a Uint8Array of data and returns a CodecFrame from the data for each iteration
+   * @param {Uint8Array} chunk Next chunk of codec data to read
+   * @returns {Iterable<CodecFrame|OggPage>} Iterator that operates over the codec data.
+   * @yields {CodecFrame|OggPage} Parsed codec or ogg page data
+   */
+  *parseChunk(chunk) {
+    for (let i = this._generator.next(chunk); i.value; i = this._generator.next()) {
+      yield i.value;
+    }
+  }
+  /**
+   * @public
+   * @description Parses an entire file and returns all of the contained frames.
+   * @param {Uint8Array} fileData Coded data to read
+   * @returns {Array<CodecFrame|OggPage>} CodecFrames
+   */
+  parseAll(fileData) {
+    return [...this.parseChunk(fileData), ...this.flush()];
+  }
+  /**
+   * @private
+   */
+  *_getGenerator() {
+    if (this._inputMimeType.match(/aac/)) {
+      this._parser = new AACParser(this, this._headerCache, this._onCodec);
+    } else if (this._inputMimeType.match(/mpeg/)) {
+      this._parser = new MPEGParser(this, this._headerCache, this._onCodec);
+    } else if (this._inputMimeType.match(/flac/)) {
+      this._parser = new FLACParser(this, this._headerCache, this._onCodec);
+    } else if (this._inputMimeType.match(/ogg/)) {
+      this._parser = new OggParser(this, this._headerCache, this._onCodec);
+    } else {
+      throw new Error(`Unsupported Codec ${mimeType}`);
+    }
+    this._frameNumber = 0;
+    this._currentReadPosition = 0;
+    this._totalBytesIn = 0;
+    this._totalBytesOut = 0;
+    this._totalSamples = 0;
+    this._sampleRate = void 0;
+    this._rawData = new Uint8Array(0);
+    while (true) {
+      const frame2 = yield* this._parser[parseFrame]();
+      if (frame2) yield frame2;
+    }
+  }
+  /**
+   * @protected
+   * @param {number} minSize Minimum bytes to have present in buffer
+   * @returns {Uint8Array} rawData
+   */
+  *[readRawData](minSize = 0, readOffset = 0) {
+    let rawData2;
+    while (this._rawData[length] <= minSize + readOffset) {
+      rawData2 = yield;
+      if (this._flushing) return this._rawData[subarray](readOffset);
+      if (rawData2) {
+        this._totalBytesIn += rawData2[length];
+        this._rawData = concatBuffers(this._rawData, rawData2);
+      }
+    }
+    return this._rawData[subarray](readOffset);
+  }
+  /**
+   * @protected
+   * @param {number} increment Bytes to increment codec data
+   */
+  [incrementRawData](increment) {
+    this._currentReadPosition += increment;
+    this._rawData = this._rawData[subarray](increment);
+  }
+  /**
+   * @protected
+   */
+  [mapCodecFrameStats](frame2) {
+    this._sampleRate = frame2[header][sampleRate];
+    frame2[header][bitrate] = frame2[duration] > 0 ? Math.round(frame2[data][length] / frame2[duration]) * 8 : 0;
+    frame2[frameNumber] = this._frameNumber++;
+    frame2[totalBytesOut] = this._totalBytesOut;
+    frame2[totalSamples] = this._totalSamples;
+    frame2[totalDuration] = this._totalSamples / this._sampleRate * 1e3;
+    frame2[crc32] = this._crc32(frame2[data]);
+    this._headerCache[checkCodecUpdate](
+      frame2[header][bitrate],
+      frame2[totalDuration]
+    );
+    this._totalBytesOut += frame2[data][length];
+    this._totalSamples += frame2[samples];
+  }
+  /**
+   * @protected
+   */
+  [mapFrameStats](frame2) {
+    if (frame2[codecFrames]) {
+      if (frame2[isLastPage]) {
+        let absoluteGranulePositionSamples = frame2[samples];
+        frame2[codecFrames].forEach((codecFrame) => {
+          const untrimmedCodecSamples = codecFrame[samples];
+          if (absoluteGranulePositionSamples < untrimmedCodecSamples) {
+            codecFrame[samples] = absoluteGranulePositionSamples > 0 ? absoluteGranulePositionSamples : 0;
+            codecFrame[duration] = codecFrame[samples] / codecFrame[header][sampleRate] * 1e3;
+          }
+          absoluteGranulePositionSamples -= untrimmedCodecSamples;
+          this[mapCodecFrameStats](codecFrame);
+        });
+      } else {
+        frame2[samples] = 0;
+        frame2[codecFrames].forEach((codecFrame) => {
+          frame2[samples] += codecFrame[samples];
+          this[mapCodecFrameStats](codecFrame);
+        });
+      }
+      frame2[duration] = frame2[samples] / this._sampleRate * 1e3 || 0;
+      frame2[totalSamples] = this._totalSamples;
+      frame2[totalDuration] = this._totalSamples / this._sampleRate * 1e3 || 0;
+      frame2[totalBytesOut] = this._totalBytesOut;
+    } else {
+      this[mapCodecFrameStats](frame2);
+    }
+  }
+  /**
+   * @private
+   */
+  _log(logger, messages) {
+    if (this._enableLogging) {
+      const stats = [
+        `${codec}:         ${this[codec]}`,
+        `inputMimeType: ${this._inputMimeType}`,
+        `readPosition:  ${this._currentReadPosition}`,
+        `totalBytesIn:  ${this._totalBytesIn}`,
+        `${totalBytesOut}: ${this._totalBytesOut}`
+      ];
+      const width = Math.max(...stats.map((s) => s[length]));
+      messages.push(
+        `--stats--${"-".repeat(width - 9)}`,
+        ...stats,
+        "-".repeat(width)
+      );
+      logger(
+        "codec-parser",
+        messages.reduce((acc, message) => acc + "\n  " + message, "")
+      );
+    }
+  }
+  /**
+   * @protected
+   */
+  [logWarning](...messages) {
+    this._log(console.warn, messages);
+  }
+  /**
+   * @protected
+   */
+  [logError2](...messages) {
+    this._log(console.error, messages);
+  }
+};
+
+// ../../node_modules/codec-parser/index.js
+var codec_parser_default = CodecParser;
+var codecFrames2 = codecFrames;
+var data2 = data;
+var header2 = header;
+var isLastPage2 = isLastPage;
+var vorbisSetup2 = vorbisSetup;
+var totalSamples2 = totalSamples;
+
+// ../../node_modules/@wasm-audio-decoders/ogg-vorbis/src/EmscriptenWasm.js
+function EmscriptenWASM(WASMAudioDecoderCommon2) {
+  var Module = Module;
+  function ready() {
+  }
+  Module = {};
+  function abort(what) {
+    throw what;
+  }
+  var HEAP8, HEAP16, HEAP32, HEAPU8, HEAPU16, HEAPU32, HEAPF32, HEAPF64, HEAP64, HEAPU64, wasmMemory;
+  function updateMemoryViews() {
+    var b = wasmMemory.buffer;
+    HEAP8 = new Int8Array(b);
+    HEAP16 = new Int16Array(b);
+    HEAPU8 = new Uint8Array(b);
+    HEAPU16 = new Uint16Array(b);
+    HEAP32 = new Int32Array(b);
+    HEAPU32 = new Uint32Array(b);
+    HEAPF32 = new Float32Array(b);
+    HEAPF64 = new Float64Array(b);
+    HEAP64 = new BigInt64Array(b);
+    HEAPU64 = new BigUint64Array(b);
+  }
+  var base64Decode = (b64) => {
+    var b1, b2, i2 = 0, j = 0, bLength = b64.length;
+    var output = new Uint8Array((bLength * 3 >> 2) - (b64[bLength - 2] == "=") - (b64[bLength - 1] == "="));
+    for (; i2 < bLength; i2 += 4, j += 3) {
+      b1 = base64ReverseLookup[b64.charCodeAt(i2 + 1)];
+      b2 = base64ReverseLookup[b64.charCodeAt(i2 + 2)];
+      output[j] = base64ReverseLookup[b64.charCodeAt(i2)] << 2 | b1 >> 4;
+      output[j + 1] = b1 << 4 | b2 >> 2;
+      output[j + 2] = b2 << 6 | base64ReverseLookup[b64.charCodeAt(i2 + 3)];
+    }
+    return output;
+  };
+  var __abort_js = () => abort("");
+  var __emscripten_runtime_keepalive_clear = () => {
+  };
+  var timers = {};
+  var callUserCallback = (func) => func();
+  var _emscripten_get_now = () => performance.now();
+  var __setitimer_js = (which, timeout_ms) => {
+    if (timers[which]) {
+      clearTimeout(timers[which].id);
+      delete timers[which];
+    }
+    if (!timeout_ms) return 0;
+    var id = setTimeout(() => {
+      delete timers[which];
+      callUserCallback(() => __emscripten_timeout(which, _emscripten_get_now()));
+    }, timeout_ms);
+    timers[which] = {
+      id,
+      timeout_ms
+    };
+    return 0;
+  };
+  var _emscripten_math_atan = Math.atan;
+  var _emscripten_math_cos = Math.cos;
+  var _emscripten_math_exp = Math.exp;
+  var _emscripten_math_log = Math.log;
+  var _emscripten_math_pow = Math.pow;
+  var _emscripten_math_sin = Math.sin;
+  var _emscripten_resize_heap = (requestedSize) => {
+    var oldSize = HEAPU8.length;
+    requestedSize >>>= 0;
+    return false;
+  };
+  var _proc_exit = (code) => {
+    throw `exit(${code})`;
+  };
+  for (var base64ReverseLookup = new Uint8Array(123), i = 25; i >= 0; --i) {
+    base64ReverseLookup[48 + i] = 52 + i;
+    base64ReverseLookup[65 + i] = i;
+    base64ReverseLookup[97 + i] = 26 + i;
+  }
+  base64ReverseLookup[43] = 62;
+  base64ReverseLookup[47] = 63;
+  var wasmImports = {
+    /** @export */
+    "e": __abort_js,
+    /** @export */
+    "d": __emscripten_runtime_keepalive_clear,
+    /** @export */
+    "f": __setitimer_js,
+    /** @export */
+    "b": _emscripten_math_atan,
+    /** @export */
+    "a": _emscripten_math_cos,
+    /** @export */
+    "i": _emscripten_math_exp,
+    /** @export */
+    "h": _emscripten_math_log,
+    /** @export */
+    "g": _emscripten_math_pow,
+    /** @export */
+    "c": _emscripten_math_sin,
+    /** @export */
+    "k": _emscripten_resize_heap,
+    /** @export */
+    "j": _proc_exit
+  };
+  function assignWasmExports(wasmExports) {
+    _create_decoder = wasmExports["n"];
+    _malloc = wasmExports["o"];
+    _send_setup = wasmExports["p"];
+    _init_dsp = wasmExports["q"];
+    _decode_packets = wasmExports["r"];
+    _destroy_decoder = wasmExports["s"];
+    _free = wasmExports["t"];
+    __emscripten_timeout = wasmExports["v"];
+  }
+  var _create_decoder, _malloc, _send_setup, _init_dsp, _decode_packets, _destroy_decoder, _free, __emscripten_timeout;
+  function initRuntime(wasmExports) {
+    wasmExports["m"]();
+  }
+  if (!EmscriptenWASM.wasm) Object.defineProperty(EmscriptenWASM, "wasm", { get: () => String.raw`dynEncode012091253f87dì%nä= 4&¿nÝØä‘ÂLÚªã9ÚØ[äº\ ¼¡³R=}L]ŸÈÿ2 ÿù¶J1jj¡é,zäV|i¸Qk¹‡= 
+¨¨Ÿ%‰€ýv²†±»ŸoúâLa:ê±ÊäÌÓ.÷؇ý×>àW>z¯°8¯ñ€\Ñós9ˆ\§ôÊ@Ü (tÂø4° ¢7fqÓg²Jè6x[zç®&4=} p.(°tÍޖ™ã¾>÷CõË"*k?¿~7‚~H2ÛÜâ.ÏQä;Œ6{ÜãFÑá'DœD¤±°HQ>MínÎϕÎöʵ’Ñӓ…™Þ“‰Ž‘š†Š‚œÌP¼P¨Þˆ*X²E=M¦qíxMÃ±=M̚ë4/<šgNO‰™/¢	¢>ˆa~Ï®”ììììì0”ìœa笡çëOÓÇM	Q9tùµyuéµµÞϒ/Ÿ±Óõò}E{òÓ
J¹Û|·ôfÒ c’¬”Wêaûÿlʽp¹|)‘ÖEL–†¦	}‰ypÕSϹI†]¢ˆºãæ°ÿo¶7ÛRqš¾ÔÅEßؑ]æˉwÚ{óç‰Vwó1¾”E­Øpˆàe"Æùû–¡Áª
‡ Ààð´Lõ›€ÎxEÓ¢N¦‘…9Ÿëùši&€	Ò§Ø!ÇFçS=MbäO?ß·™縪‡7ùa}5ðšûÕtsUŒþ£Kïg‡ˆN™¾)ø§\V0uSIö:ÌU4ж¯´Õn9ÔƒèE£ZƼ{hµmى¾6ÆžÑ+xñ´«„þ¸=M‚ߤ·å®«ïÆGFÝì|H?äE"þ!9«Æïpæ'][¯ù·£W÷O§&#aŸ‡x$qf=}ø ô bϗŸ×W÷LôožÝWQÕӎ)u†÷½èV|¥Gà¨Ö¸˜@Œê|ÇK5ò	€A·Â9’CS2š¸‹¼¿,ä›ÝÑÝy™!ÑR„%ÆÝÎ0Âv§ qTcó±hØÉã‰=}Z=}Ælü­ën¯ð(-°ÜwVχï.th¥í­‡S~SÏ»Z”ZÔZ
+3–BÌÛ¬•<éæO)ÎyÚ¯O*®uìÛ$öI¥Ý9ôø³\¤ò³Ù¹ÇP¸J׎y@ÔyOÇm—’ô½üœš¾|S?2àú¤F?½ûoo3ôž;<àáûܘ8‚ì²7ïë¨RäY¹|ÓºÌF,ƒÐ™-¸*\P!FJÒ8= o6HwLrúº”¶Ð۞\Ù¬o¢–9Iq„Ý.ôf¶Îȏ{Ī×N|Mfs…•¤„ÉݖàŸâ§‘*+㧭’ô¯î¬7çקä)€Š!Z¨ƒÉž,Äp~ý·wsSGó—äs„E€\ýï鞧Ö:Ò'“Cç(_X$\¦½eҒ8$’X˜F|e‚•œíٙә‚†¡¤Û<ØÞÛ¸9‰
¿ðÃÎ#b~× ‚4éîÿÏq
+˜ód‡|0•wU‰—&®è·vh6¨—{Ú珁Ú18ә(ÓY‚\ƒ0¦= çˆèíß)Ø=}˜[xü-v˜?N(Kk‘gš0}âډ´ð“†¬”œÕQNÍ¢usѳ=}.	ëg…û= ÍM—B
p'²¨ œx’4è@9t“§eݵ¾âð½ z?†‹Z¹FH'‰Ì¯¿<ŒK,üµ<{˜	¶JãývåàÆeù0Ð"F¥ÃÒÞŽþԛÉvC›zl}„ðN’£	Í^ƒP%²¸FX»WÎêô¶…ŠäÉJ^gƒ×SÃã.žÄt*'ªG‘«ÒB<ÜӅ¿ºp­\àuV¯£›Åݑ½á–Þ ùߞ=}ÎÚ^‹Ÿÿí>¥!¨ â=M·?*/¤"å)â·ÿîÿî*(%*›2[½"üríÔ4š’l½»a}¯CwpCÓèìGc-ã6®=M32†k?Êg­…–!So-™x›>³G+ã@ò,™ Áïƒá„åN0þŠÙ‚è.~È÷¡vTr¶‰­‚Æ[üB±º»ávëw¹{pÜºû"Aæ’±9Æ^¹³òïRIAy5GÂwÉfœ4@Tù|qý7†ðªwBL|ÔqŽ‘v!ª°|]KiÐJVQ5‰¸åõ§‡‡åŒ"H¼0e¬<óBîÚS€ÏUìHPÙA+çÉ'se†ÌNf°@ÈM,ð½egÖ¬x©“„‹û½2~«ŠÒ1;ֈ«…¯°4&90èE»Ó׺ç‚ʧJ<Æ¿&~Nu¼ãÙµ¢.UÇä(qQô^ö–·“%!É
+w¬= Îôª«…Ùת…JIS;õa rx×£.6¤ž°>5²Åà,õ°°h6ûUp©²v#}%é‘= R¢hõ@ëQiJٔ\ÛpŸ»©[vsiÙLE UG*sGÄ%V­¸Š§;º_]c؄p#¡:oZ{ãS5I¥]ÓaÎg+n×ýÿ‚Txy]²ö°k¦kêju¼xÐTá©#h>Ù]u\EA+§…퀤u¦ü؁lQPdë„NòzyÞ¼X€Ð]—ˆšÝøÝg¸BŠI¿BÕð_Ël¶Cuyºr|<¾¨Támo5êÿú>Ɓ[ã±G¨²)ü&áòüåBFouŠ!Íí.jÖìß½8¥Yëìá›ÈÁi—)‡qÀ:ÎüÐր¤Gͳô>°ú¯øâ?R£k~&ÑãÞ~AŠ¢;Ð'àÆUÀ
»Lž­×)‚-!ÿkýí›Ù
+§Û\{¤ólW^næzk?G~?_5™uÝñ7-ß«6YPðGßÚù\Êê -ûp¥èÓtM×hKȯ›ÒBAê"ïx×HÍ0Ôcè+èçÛÅf (§¢õ®%K£7éÞQ'MxãxÐúр…2!8_6̶Ì6Ìrûù
S¥Zƒó
AIŒüå6¿jÿ_°(ÿšä9©CCÄ!bŒq5Öô×x{ÍbÆÚmÒ@«µ××~҄D“;*ü ùeŽ
ÀÞ·xˆv¾;¤Šƒ7¾ƒ[W\ýüb›@'q㵋ÙâÉE¾}}“tq-g=}Üs¢5Ó=}$Ĉ§£€Ó~SFÎgтn†N>1§/¥¸ŸG5àM8#ŠƒÒ;2¢/K%›–xVÓ(X„H>µ¬ü;_˜j~Æw<¾ô*»ô= fAËbM¼iÀIIp'c*”:oY¡VÖ3ˆ‹ûIdû®4ڍûýÆð}ûN¥û–I
+Š¥ÎŒÛK*]Ø=M>t×ý³MwE”™è®"ۂ4­]]ÓgØ×EÈ.pN°¡š»¤ç/I.ÿ+6r@«Âz@§Bz@¯ÂIê-tí‡Ü«°·GföjϘÕì:žgÕ‡UÖ=}÷¦|§Eõ̐$a*¸›s¬´«£¯
JÞàãËt™$š GSÚ³Ë1¯©&|±c!\åvçϷѸãßñ]á¸?ùää%6´= #e—¬Â;IÚ¡õckCÀò*\ï—0À•¿<>ªžÈåJA'ï´—¾ME.@OüІ0e
x÷#2ÒùúµƒÇ½>o{›«ó= žÔïŸ;ǽ¶óЉ/†—Ô͌܂€¤±¢Ê’…w>ÃâС¯œ®Üa£¹6ŽVý v†áÂh‘ôàÍ8˜D!Æ!ÆI;¢á܎Ž!oÑÙ …OÏKôò=}w<0rT= 5J„_±3×Ì;ôYÐ<aÞꏹ¾7ßz\˼Ûۙ@>Â{å%K¯
º'ÊmÚòÁjRÒ×úw€@'(	€=}­QU«ÐÁђ•„,/?úYE‘yºQ얬Ÿ {ÇLÕæõNáð#f>_ò#Îv]˜/øϾTUšà/øÀAÔ'w]€Ã]€W”•w]€Ã]‘X­÷Þn‹ð·TbAåÉ	r¨4?t²„>1Ç[áüx $€-ÒÂM†Ä…§·µwsú>üÂ&³÷.dgA¦h²*G×	öcG×µF5¸Êqª$ñ?¦vÿ<ã;ÿs­Òi›ÇXòku®vUòõ•cuæʦá«þ¸‹ÍŠ
+ÑʑƒuãE"þ!6Ø Êæ­}}onË:W”•½¶‰˜«ÊFˆuÃÝUS-1ÀÕHòzµöƒ?ov»®¦‡
+CyÈçaÆ
+pÛ¢&{µ¨«‡±1˜EXÆÂu
.7ž
˜
÷²ÛJ’Ê‚y[å²µ»bL’?·×øèìCp:æÕ駷rUèésÜ[o²ÛòDòDހ]ªä#çN’;Ïð)â´*z80Úèóª1çE¯´Rì,D4H(øË)šgp=Mý«û»=Mþt8º‡-HœxH”}Æ3Rt?ïɤC
+§ßìéõm†õ,;æðk=M6ЦuSÝ^贮ٙ6=}掍†ƒóO«>
+yÒîÐ7‰a'ûLUöø>ò -6Y(¬ÀM’Z¾ZHpu°c«à±[t*Ç*jwÇÍ$Áíqx©SwћËR¥é®[XJŒÓ8=}üµnt9“ÚÏ3z½¼¢[Q2Þ¸/=MP§Y&y=}ÚÛw—ëý¡—àߥۧÃŽþòýÁœÝÈìûê(±€¹4š'€ïÌ:Ûùk=}eªãä	ÒCKA¤Æy×nvȧmÿŸ;=M]¿ÕŸ€Õjԋ–ª	sF>úÔ©áÄ:cÀÆ<$|ê'!גSb¢V¿oÇåGð™¢U™ÊŒ	u¤ZJýæÔÿÿ	2ç썯h£‹f¾Q–ZãÁ	®‚	쭔Ç'ÎÅ[¸¨‰{?¢ÉhS5o›ƒU½c¢ÈÂÜ»JZmUí\áùµV6Bète™Ÿ…~Ãw‰÷0ÕஜísÆk,{ý¦û‚iK+xvÅ兺ñ	‡a”[Sé»Û	Nõòý¬ßà¨= 7p’å^ÿÃW,¿*M½áR±Ì–‰³FcË<üiÏ2|ö^vKÏHœò¹uY“bk¿mZ¡Oš^ÿç©~ïj°È”7	Žl©¨ç”_ó¼'½ßªåÏn\ O,wòi,Ū-¿?ð­}òÁá=MÍ®ÿ²›EÍñ™Â}¨³ô-ýƳúŠù5†6MÃ6ÓJz=}p³žûê—™9õà垫TM×Ve>G~ŒÙ»Vü²öHByf<õ©˜+QWƒF+.ßAŽGÔ¦ÏèÚ½‚3‚ˆâÏYÀ¿T¢¸6ÌéɓÐ*¸Öª”ÏrÍëá=}6‰/U´ÃךZœþðóW.½ÞQ¼¾Æ”qÅ‰½‡oâäB-ÓU‡€J¬má8øª€K.Œy±>.Q¡a0ޙ#!,¥BÞ¼­S?Ìr^¿_Ö.¹ó{=}/äÈAt}Æè̼4¡—Ôîgl]ÌUEý{}|DÏä–:°š-Ñÿ°=}àØéÕ}Êñøðº~¹¯4Yƒqm¹]!ºÿ=Mõ«ˆ‹ :Š†N
l"SÇps¸Gåȧá+’'M¿ÓîÁ.î¤=}„mÅ8Œ)¶rrHá"ÈøÂìËøÍ€í4ôŒ7
2bbߺq
¿2ô=}A5.YV¬ÑÚã«Þ[F
+)ºhXûÇӔ>È”?p¤ðoUÊÓ(€‚³FpÊi’¡Ð}SÚ~E ”!›|ðí‡,Ç9½Ãë¸Üì!¤ÓÃX%DBãu”&d‡ÔËôŽg¥‹á¾l¿AÉ)Á±†Ñ߇Èßý¹ód;|¤Z€»#ñscµ|¡…ÝOOe^‹ã‹ÂxÝ‹Í]¯òbÏ£÷ð4½ïÖ³;û/ºsñÆðFØIn²q¢©”*× kdO+÷削ҀiÉݱîBr]LÜ|8ƒ~7“vts÷9l|aë»EânӜ´GGò„$ÍR,<e0i¿ª
+±¾…àsÓZJ¨?&%Æ~-ǵª‡ö±;ól"=MLgÿt#
+ü˜2 <Àn¬ÉäÍôÿ®É1S’Ä›à–= ôñZ¥-@z;¯‰üà¹ìJ͑=}ÊSeBÞ¯´~¢smÿŽ-¨CozÀ/;Çël&uñZÖPV«¤¼Ÿ´ÀïY҄™˜–~—=}DrƒâgC	§›ýçšrÆ7âÃ$ÿ¤Ý˜˜š~ސÝo@°³ٖsŸ;ozûÀ~R§ú"¶ü/ôcæ<œ°^Ôã/žéo•w×ër¦_UgûÀøäâkHț{&ÏMëqÀYÈLÁÊG†bÙéŸ:ˆš·q]ä\™PÔëÒ¤a£1è]á…^Y[›Sw¶å²¹gÒ0ód^žÈT.WœÄÜ[ՙ‹ˆÙ*Hi®z¹µu}ýuý}#ú=}‹ÇÌRSûç—Mø=}¹¹>±ÿì¨áØ[R?ÿ^‰„¦ñê¾xZRS^PSSSç1ù}݈Zá4‡fffdf¨Õˈw&eÜ$hä'{»Moöyg8¹ê¶@ìƒÛª0-ó•¯:¹ e{™†%<ÎÖ
›}Þ¤v’ª6¡Àõ÷Gh8= “FºKVñ.ºHÅ)<Ñ= xs¥B“E;;áF¡·!¡-ÀYԖå^Ö'l̯ßûç¥køނ?[ë>†" -9±/€ÊÛGǘ	6OY4VÕ»ºƒ[öBÿ:B¡WÍ&½ÇÎç»Î= 0y恧§5àÁFiA•›Í²®Ê\¿<î!xÞ³E =M¬U/ݾss涵·O̐0§GûúñŸòŸ¯{^/~ä׫ÊB= ;4¤þû–^Öï÷ŽL÷ï_ñíx<õ;ó5ËÇ~¾V+䅒lƒ¼Ñ°«Ôí¾)Âfš‘żo¼ÖùWa1køìFvœûëûRQ‡ø]q’| ï0g–…ºúîy["FÐþ7^‰Ò‰RµÚèæøÔyÚ
+«ãŽˆi Þ@ˆ…U¾¸»* è#ò-ì¶HÛé¢ùL”;}·O7…7ÅsLæ
þý8¿Óùñ£}.= 	Œ<•¾=M£ðQKTà^O|¸üggH«0³i£im¼_2ÿö”úÕ¨LaO+&]L¤šÞ+,k Þ¶Ñ~T¤ÂHì ÊèèÕÀíÒ³M܈‘ô~J<¤0Yð¢´."»â›èÄxqe%o݂yå—æâ¹25UÐ/’Þe.×´Øì_æ¯_zRÏíšÑŸ@ÿôLc¥Íðy
@YΦ}µZ:ÑÂgZÒÒ(©¢‹9ß	€Yˆ«¦:™“v„ÙëÎ€ZJâÀVsOt™UÖ Ò¬¹‡1ûÚG´OÃóG©‚)œniÇí
+Ô}½Ž3:.ˆk]ý²ÂB=M~	–ùÚYp95½‡qýãë ÐÞ/¡(ä'§œ
úºE/ê«ÌŸ9Ÿý%Ú!<σžJP&|[ƒ,gz’ű¡\o•0™
Ôhûóþ“œ¶[KêÍð= TjÃVñ¸ƒƒD¼Ð_Ò
+Ÿ0Ø_1dPðt  ýtZ¾rù
 àJf^ƒ”;Ô2éÐ=}è¤B~ŸDšñ7ûÓÁ9³ýbA6ZØ´èÃg½ñóø.:~ï ]bªZŒì¿Ö²2QÄßo¥-¼Öá5uu/u³òD‡œ;gjÀ‰ê”ÃÇ|eÁ9¬u$*ÐÁ'ÓDelÀëäì¥Ò¤Zší6OÂ@âF0-J÷¤=}_Õ߬ÒlÚM½Ç˜ôó~ð76›DEÖ'ds´Ùï”ÝßøaÊbÑ «‡^“™Í}&àØå?¾ÍF\2HD5òèÁƈd˓„dÈ·6ÙPÑ“|¬Ôq*Ê>ƒ0š¸Cì(ÛX‚YV…²ýIpъí‹M	k֔ů}Íóôc7“ÅŸbrñÐeQŒXæ©Æ¯ü_Û»‚˜ÝMþ©.c–kg fq ôo@qRL°šÅ‘Y΂ˆÈ»d'™<±+±î‰,Z­-GG»ø$âG†vÇû	µA~YF5"§)ð™fßÐ鸉oJRRŝ¿ŽôXÝaú.QMw1 1þøiSo¾®È²¸hÌ/Κ })f
Br.G1£Šº×cÎ𥰹&WÈüAnŒo#g ÃàLi²¥8ó=}dä¥$ŗ(³0h¢0OjfÀr¡6*#àæ"ãûQ?ƒ›ñ±«²Xóä*hïx=}ÎÞ¬výÞV÷{u²cöê¡h¯QÏYaê‚L$¦ûÈçIGßþEýWöºýëÛߐý×Ïð“i G´ì=M¦”ßÁý'þºeâNւ7ϝ/сuž·6rۇF¾Œ¾aUÌÓiÜúÒ]¶éUY*= g[ 2-_•	c:ðY)
+‘¼9ŠîK¨‡£8†o•Sˆå¶K4U>+¯Ãî[H\wâRVœê/÷~Ðn•m”–¨s8CÏö©Ø%ÀašªS]ýŽ¼§ r_¸ƒk‘
+ªµfÄéÒQæ2¹Ão¹&3žžÇ¢u c5ë6}Í:B£Ž´1uiˆèÑfa’‹&]ävCŸ‚Ox·"³L˜Tè.€I.ÊÍzB!:FÏëxS´Q{ÊõZ7Uh8yÝfDÎ	dÔX3‰Q±	½–=MnØnÅc"@;f?ª¬nû0Lp´h„,¸#Mà->+C= Ê¡±‘­^ٗ= ®Â¬QôÅùî
+‰öqòbŽß=}‡•±ÕAË/8RzT³…‘ÃÌ/_îMvÛ«;7S	ìN4
+ìŽo7è_¤ÀܕñŸÜ©è^U‰±A{Éö”žìŒXtnÝÇvz
+ ½½Ùo¨’‘çaúâ?EH”Ä»ë"‘±cÀÁEB]acgdck
+ËÁ˜EŽv›ÇڄM:¸2¼"ŒûŽc³Ï‰1mA]ø[à
= Ý|«oÒ&¡® ¡ŽK$ÚiPÚÛaº!ÊI#?3ÄLoxJò¹<•$$»¢”¸h.ˆ‡ÕY¡‹g Û30ׁ ‡¶~ÃtéR0 ‰ni6ôeìa—z(¸9°Ù=}ocî†#üR{¶ù*×<Ç‹\Ès„a>#¿]¤š(R F×X#¢¯mVRòºÃ 0ã51ï‚íDÅVs“t‘°YÎ=}ø´·Ç”F ‡ØÕÓ¡ð—(B
+€YS= '0“#×KB<rÔôþMz8”ï³tíY­S\¿©æ sŒ¢‡3~ÏcɃÜ[öÝ-y£îu(´{©ueŸØݪ	g×»c*5쐣¡“І>¢9®Œïîêzr{½¢j|W¯Cú²‘"žÆ¼¦Xçt,òYCIV‡µX#¥‰_Žæ)‡3è "9†ûã)‰e…0߸Ûͤ³.¥>„å*ÁpƒepœŽQkîtÎڠŶïoÔ¸>³5„5Î= †Á¿rà†
3S\ÌÒªs0 iæméŠQúR|Žë²­FA€è	Áç-šÚýFå˜3$qϒ3˜+w؋<üªUþvü‘£b”)Ný¯j;0õ”}᪟’[6k	WÇíH®	¨{2Jþ!y+‹(-òÉýÎlœ  SÆ_¼òu8¼z¸Rîùq_fGHî?{vTgeÒU<S’^£(îl=MéáDÛ¶­ùM·Ä7^õÿ
+Ø£™ $\ öv=M¦†px™6+ã*àÀìî{ølÊEy9² hω³!ÕÑjú¸ò5pG£¸fëp šƒ‹‹N_::û\RQ[â£
®M¿L#8¢ÑPk5]ý«¢zžg»güšåÐÒöí<ôâ~ÂÔîtýX‚ÙñµE®:¼VBͼçtnHç­|Ï0[óoûŠM™>h}ìAö…":Vk=M©l\äÓröQR}8qeV<J"†ÈFäíûI_Ó㎫D–ûëôzïå‘JNHŽeÛpµš…×8挓ƏPI¦û-t£sp£i¼äsç)’ç%0eq#„ôFør\ÃÁ
s•×CP÷ú½˜ÿ”qH²}EéÏtjT‰i.•Òþ¡=M%ä¸Õ’“ِe½_ëÝ;+ÏÁ9ó+ä·9:„׎´irxb@åÄä*Ý•
+²íC­K„‹Ý»@‡;ö4Päü
+cãJ1«õãLPµ“ŒêY‚àn12ȯÙI…r+˜= ¶/gýZ³#³}~å0ž´„ú¾dȑwûŠ{”èÒY­uŒvëNô›ºô[í&öõ¼[9Ø6
+>ßNçRÆÛeí“u?ìýhWõM^8<˜ã*lkê@uú.FzFë=M-ûhêl
T±ÏÌÚ®Eã¾ˆd¹P±¨à<ÛÉ‹Ê6åÉì’
Î7Qv¬ÎÊýžì–$ºÑz†Ø'”¨mІØÒº´€ZM°o9=}óÃQ·»¾LW·:+¯˜’‡©p §àÕ<Ïí2†gþá1é9|R‹ówàutHý8ºï@¬^ŠŽ¢W¶—©ê	]ð½6ςOô¼<±Š—GãQ~V§xâ­ü1éUM&CÞÍ|„A<^ES¸3‘4
+“Z!¡–Ú܋a7Î0¤q1çÖ'©
~É ™‰ÙWüã­)¼ðÁê1…¡é)ˆ&n¬'eÚ!6¹¾P;<dm-TŠ©ÂñPÿo࿧Úì4¢Î³¬¬iTÑ9ËÀêIqþdiÉNì=MW­H&¨rÅ«q,ì9C6/¤t«ô= ªK5Â#f¿%Î)¦k Aù4jFœv7üÃ*-Ð\é̗:œÄ²21 .›œ¨½ü,= åÔ3VI¯¾¸þ¼¥ÂÆÏç^g°(QÿiÕ¬•ª|ï
+Êáu¹ÎÖ¥U“UÁ­YE¸ã²öÌÐm®~—wø%þz„êÑ5\5oF–n$»9³™mi6šzj1séGd¯Éؐ‚å2(0¬>nE¥âV˜Çú°ŽÜé›Õ]þ´–Ýsא7ãû<ŠÞ맶§V"íٜC'—œaÓXK£¯üYü›­úl^~¦¡—Rû!“=MÜPa´…_Cë.0£\}À±QP›9woÙæQù§j˜KŽõ û@É+gI4…wÖü.Û_éš4GÆ·#ÛxEh6–;L]¥2¥á5üP4õuÅ	>›çò-ç»ëé;]÷ÑÑY¶•Œ	v…Pö%‚!̝§8÷PÛ'rö§ÙßÏËí»kæ@æ{¨ËC4¬P¶Œ ’óڄÈsåÍý£ÎxŽ)ÜØNóÐ3õÜMüB‚¡Å–ø‚×½»#»Ã-á;Ì'œ€‹Æz{ã­MòÆ0в>‡v‘©Ø¯³û#iàBé]á¹F{srP†Zá:ó‚öCŽÜ±ÀÃÊ—õ†p^kñþv1_Lç9νdŸØ¶ƒ+u¥˜æÌ·’ó“l~«‘Ù„îû­µŒ‰ŒÕÔebyˆÞ«880Lˆ²5ìæôvZÉQ—¦HV/€ïF{8M*˜Áý¶ºÂؙO~ü‚3|ŽØx¨>Œ¹…çû֓ú;êŸ$hÌz~ç1Hún41eÆOXØ&É¡:h'¢yÓSvðxåÊ:µÆ-Ð)ì•_ä;k@%"’w¨s“
+ËØJ‘­V+á~àé4È'QØÇÝøÄ|^	Ç)"¥0Ǥ„Ðñ kÂe\
0¤|>ÿI÷ä’ÒÝýÔ]¶;L	qìÅR¥-bE]Ârʏý#8n°»ØÑGø†,RmâAê_Ãpá%/BU#tΊq>ò*öú(Ž$âešò|=M)!‚Ð'¼¹¼R…ÐzsÑxˆ
+ß+Ž.¼¢7â%”‘²0ÿPàiÝPñ¸˜MÏ唀:L兙-üœgß=MƒÅ#MÚ+üfmi®= µ¬³ñ}$ž¨9<og"Ø[x«Æˆ¯+_–ŸÐ N×æjV¦­¥˜#—Dw—$¢øŽ"ÂK**¨N]EB®°Ëß‹„Sâ^í%Í(æé¸ÞögŽÝ¢´Q{Ý»b§Õ×±±hÙ^6Ÿ«Gàý‡QÃe]t„ŠÉ¡šQ¯¡šñ⸸a·12À I¼Æ÷nZQ:bùh<c£5yÞ§è˜~xWÀ“Ûý$õAXÁÓ4Kóݛœ×¼„µ•@ߺøz¶Ñ1s7‰†=MÇ5ö‹¹k±R%׶Hšâð/
++Å»ºD’ó(=Mj$×JD	ò¡Æÿ¼"@ºqJº&Ïþ”IÑKÍP„çüƒzDjIö
+¼ììoìì¯íì÷†;#¶º8l”¾k#:âõØ
÷¢™ ü
‰_ŒWNì¹tjϔuÐÆ>I¿Œ‘y Høœ@u¬BÄÎ5Ûy:LU&–ù•ð˜†£Rn̵5ZGù<§h¿ËhÙâ²zí¾“¸?J‚àçªIx˜6ìÚËìV£áøˆ¡›h²'ºéÞXQÍНS݌ŒdÖ8هßM†9ˆS}‰À4To0ömeΦ\ܳtQÖç'Ñ"Á©–l—à¿ö&.ÓÚçï±í¥­£ds¿Œý= ìZÔOäþr;Z©’ê–ÜÔ‰Ðó>B:½î-t®«˜d¶‹L­Ó¨$QèÔDϟ:!ˆì€ Ûq*sª4”xã´®X&(\À¾ŠÊØXA¸¨Åe2PšB…*“S{™é‚Ôce YÆBº©¦lÍX;O²:À‘d¿fQCŠnM‰Ë-ÂÂðǀ£ï¶¡SÚÁdC,KÂÍõÞŽ›=}=}ߛ ”2•y3‚R¤Ö3=}cÐ'Z®¦ž}±)„\‘(YàP8?ÈÚÂÔº
ǶïiXEßÊè= êèŌDÐ&sÙ¦R÷_{Ù±4Ë2	ÆzãT!gU¯CÀ@¼“û7"ÌfÆúX«à-öRÄ‘•êP$#¹‹oü³ãqŒ¿«í³= sü§{ÿ«·=}ß͕ Žq?¡ÏÙ¨½Ãç×å?ŸgÆ‹ôÝi,×¾ž’Ö³G¾»= ÙM9jA¿œ¬R¶‰Æ'‹sÖæe4æ+6ªƒ—À‚UùxƒG›Â+ŠYbçÅÉM"ä˜éÁZ]&ýŠ¡9˜å(¡nn¶1Í^¡<ÞÍeæ†:WæéÓ#4‘Òª“zB˂ÿ:°—5G¬ÛÂÒ(âÄGÿö*ë¶.ï\
¶l^Iì°Ô‚üZ™ÖKXSý¨'	M¾b]±>Œ0l›ùXŽ(^^
¼òçHÂSîÃçàóˆ+!šmû¤šÂp= w¢·nHµÔHŅp™ȝXw]Ž©5"1ü>
+±XZ^Î9â¦gþ=}oäíçY÷Wé[~Ñ;=M㪓¶&$óÅßah
+ÂãtÛókÿ^ƒÛ7z¶#X‚@ù€rÏ8FŠG"5ĘÐÄ~áUҜ8̭ˎÌe3΍ñŠ‰A’´ºÌ
=M¸óÆ~2“Î,ô®dmÖ=}»u¸ÆŸw:á!@…-¾ *ïr±F¿/͒;öMÅÂ1¨:4>&YÏ= ¬]ÜèÁ/4&øö0aM—ÞjR»5bãXq=}A%è9= ži©¸¡l¥nô@ÃOPz—ƒ»wƒÓ”ÝlXœ
+:ÎÛÝ(.Tɏ¬|©Î¾²ð•¬ðÉçiå_*&F×[Ÿ	oô8B¦Brþ=M¼-ò»ËÍF?<@üønÍ|ãžxÔr6hÚpÌöç#5‡íl÷.à@]ð‚{¹ø÷ì<Î<ÂuwNLO"_u7°Ïa ÿ\ÌrîÔdðó¶§Ô67¤p£"ªCËu@ïfcOò¯x¸3	²#lf1}U¬q±ýx¾
jõ×»ó±ñ	ÀR³.ÙýåПéIcΗ‰ÿ;F? ÛÝkØýóÎó•ø‘6¸'áû=}žœt8Ô]&ã
°¿|%BÆ<Šþ·ÎÜ«ëÍ>YUˆÐgæE¡ã(Á…‰
+8ԐXÀ­vÏʨ¿6bnµ¤GԒÁ¹§\)é«®~žî¿w"Þñ£à/o¯ëOï“r(ÿ
+õOá4–¥àyázƒ¼}·‰æ̲ìB#ƒÙ„ø }…JÏìN\]=}Înü4V–á‹a›ÉlIA	Í<œâ:^&q/nõ×n5;=}Ù,ìâ­|0Bõ=}l;Á¶®äÓ=}a&¼½ó…ß@”ÂU¨¯ÜüHÝدCþ6ýjÒX_16¿X]~Y~;×*½ÿÊí²2
+=MQŽ·ämòjybá]ÜÍl#à(‡Kð5ÅôIJßqE|s‘ª±×ÿše¼ˆSÐo“^[ØÞôX‰‚Yá4ô@1³¢ƒ[#ïQ½,C
èoJ	9Û«ÐKvnC&Â0 »¼Ž°SäcÑ07 »4NòÚhr/#ÉRƒeÊø?°Oí„ÿójà!c³hziÕ§nËGY³ÿòò,8ä¹àø¸¡µ¨X[|.ôóv3<÷£Û1²a<>G¦»…–=M˜lf†*-¨>9C1TQÂñ¬ì(*ø×d²¬p	?n=}ê{ÕÊd\ø\*·×Ré„ÕR_Y>7Û!èc.¢V;$|òè¯+/U€cMX?éŒ9À‘ÌéZm&Š…,ôvõÓé¶ZÍ<VӞü°	Tiš{êC§)ÐCU·RsV$gÖ¦îÁƒ ÖPö4fÃщ>ו¤kc1W\‰åÅ$Çp,%jŽ1âÂ>†¦¹Ð¨–XþùïäœRÜJ¿o{FúйÝÚ³ó£ëQE@mj6¹e¢Ñír»‘{SŽg½ÍRâl¦í"C÷Ö]§@¸š±ë:Â(íQóƒœ9È«Ëîqw±º{i"ÁŽjêévVÏ¿KÐ÷±ñ´ìp¦o.è<wÕʈ¾­Ø/iºdr2S£ú~&‡Oãè.¹
+x*q‘žT·gÀúÛx¢/Ã}ÜYŽñ-•XlEšìøöt„¢Ù6ÀžùG
+;%eU	àQ-ð„ÁÆô+wcq÷æ͸S©Šl¹¾!Û¬O ISüu9=MÊ-	!²;ÅUº¿v¶å±ØƘá¾ @ë]Lke1³„,#o™¸òÄé—ξ$ê¯3eI• ŸNö+ãsQøÙö”á9¬Çì<= 	!„#\…]ôÅvÉpšˆlñƒEÚt^ÍU•MAϼÆüÓú}Sú",Ú}Î>€P=M¡nOcùÀ˜ÑþQ{¹ˆËÂM{pp‰
•Ý5o;Ž„Úþ¨Wå7°S'1Ê= Eºg"¦^€H m?P¾ æcà à°!£!f fT(Ø#ö%P!»3àc= icƒ ‚  Œðü3p £"Øä¨3ðE= Ÿ"˜(	Íè±Sàçg>W š9μ5'¹ñ3”•!©Ý¬kD›«êíSã‰Eèí«òªý+L—o~EhÿÙ%á¸ÞÓ®©ÆPq²@¨Ø@Ÿù£u/’§>®\è¹'ÙÞ'ë>Ϛ°cLŠX«züè–CŸõ­NÃö‡q«OëÞ
k^ÁÞO}a=}¼eŒaþ²ï.5
pf°²/‰²Ú±Ë=}‚lZOÁÐÊSy5xŽLQSSOwø‹††›¹¹Aì외;ÔZ
$O0‰\6ŒkÃÎrÉŞƟlØ2²_(™zŸ¤&ìL¥âð¼[¬ºIPN¬¸/3†ö¸4†=}s¦•Sgù0ÆíÛàƹ(“â¬Ôÿ²Í҅ÁOøVSä®P†þWì»9ƒwx^Ôx”<Ô¥KL¹ihxŽ\ÜpÿÕ;<V³
¨Ðòõ«çÛ®6¥Ã†XF<ÿCà)Ss¼4n9ÁƤ%çÊe×X&¼1öÜe¯“¢«†.’iX‹É¾H‡ù;%wì”ØJ|ûCœà•S-Ž(Wú®{®û®“Zñ¢”0“Z夒›,Yðu@­lð T*¨%­ëXæ¤%tÑM̊¾¨ÒsH*sHµ= Í¨‘_T5t|–Ì€ö¯ö"XöNV£mYö”ÇzÿqovÕÀþ.‚V	*Šz©æJ:ó’4—pÝH®qû§ÃŽE¬\Ú®‘T±“Œ*W¯2¦<Û¸àăaxâPf<§PªQç
hÐù*öÑ
Xª‰ìX»
$vÐ
+X©eL	ؤóa³”ÝÆõL™ÕæÔº¬š™ôô»ÿ˜4)D=}¯)3ÈÃ
¸d;=}ý­ÐNŒÀ"=}™{Ó¬IC¬¼õâh@±óRF¢òZbs9°ö§¦š1„­³az8‘ì‚>+âTªH[Ql|¸ç6¶¥å@i§CšË‰¾Lê–ËGdÔð3Ö¤]äp2ºþW¾’d¿µ(H&b‰3Õ;ë°9Ûeôó„®jdúQÂџTƉûd7.uo{„Ø<Züºæ:ˆŠ'!Žî»Ø­:iÄ4ŽÓÂÀ,¬ôQÁ]v=}/·tæ5&06…,ø$ʸt¶˜ØMõ‡ô[ªƒVÓÆ=}Ƀæ¨@A¬K¢§«Kä>N¬È”]‘w5øÚ®dC{Ž¼æ‰sœ	ÿÛ3_ƅ†OSLœMÔk탦…†ú¿…††{††††¦Y“æÕ»Qÿ›E­L‰$1îì™4‰:›6Æ=MrZ¾6Ày{øA<(†Ål1 dbm7ÎN !‡¬ÛŽlî1_ƒ= ©néµÂåÅd¹¬V
k.d,4Þ3~„L‰òôޟ1ú¦·½d’=}Ž–q©7švzaY6én˜±Æó¯Ã=M€µ\^F>ÞªëàwÞ»ÏÂËþúækéy¡½‘ãyÝ÷¥³jp'ò…‚°;c9¡Zs&‹×]Ñ]ÝUî«­>_<(¬‡O˜vž Q×*xœu‹òRN*k;*0䅫¦—øąüЩ{ÖÔY—å!1è;å&ÜÃFUfmü&r3ÄèÄQñb)š2ãT#À·ÿ¼%TqˑZs>cU´ƒzuÏ	¸Ú‚uQ=}óÐ-G»ªM(e²ZVꬽv‡¸ ͦO‡T·S°{@R0MðaÀ’fȵ̂_Òú|â<ñ¡îйAé܂”b+™!¡O#*¾ï3¨0âšO"͍xÔûÝ
+ÞÝ'´Gü’ír”-—|zþçW掯›$×[ÙÉJuøAD!>'o0K¸’5׀=}þ\e8
+?»þÆüÜ=Mƒ3íúPþræ	MׄÖ
q&@ýÑWnBӐ>7„‹ÜÉTùÜQ¿^®ñ-,å!›'9ìsùÃ4?„šBTu&éçãÎ,?(&
ój /¤£™Eà'â£= R(/¤¼=}Íf÷I³•HZépôSG‹ˆÅQ‹¦˜+^@]ñï›GXg€¶ò¤ssÀ	­/µ¨/6ʟbÏ´%°/³~å—¨š5|Še¦U9¢’$BFpŸ´„¢cë±²êÒýœ´f]„ð®ÆÆÓÎa.$ªó=}´Y_ó싌õXóŠ¢Ëï|3;-%ÏS…ˆ)’÷ iTlWôáµa6m u¢Þ>q9 '—I±N}ÞC>hïˆGÒ*Æ·¸PØ¨)Åé
ø¯Ë¡yè€Z?1„^B\pü–ž™õôÞ燹à Ôð4‘ÚIšsmQÚÆû¡†Žu™˜°|î–(®±Ø—¬$©•+=M­‘°˜8ggÒ
ò›Cƒ“ÆK€
âåþ6…Ä¬Ú \Yý°-дXÇ̇íÁڙË2ñ‚=MdŒÑkhhÉÃd6ñ‚«ŒQt»|Z³Üu֚Uh——Ï–½çØۓ}½SýË}˜©)ÛÑÛÇwƒßC ¾ã't¡a.ÍJãpa/	ÁâÿTV˜Ú´­ý·ñ¬?{«<
+M2I©O}žš³&ÿ¬øŽu®:”º}‘ëßGnêtF@1«=MÉØ &‡Õeî%~ïNõŠI'‰‘Oöz›:?*<á°TEŲ{Ï¡xÔ©žä¬É®ò%‹}Iù$§	= s~——;Àí–T/ƒ¢•¤ö…ìpg ££»¬údl°„yŠçðÖïf†“ʶúÜÃï¸F÷ÌìÊÝ}}yÑ^Ö½Ì~Hí­ÒȞ٥¶kmzkk£%&¡Ëm„sÖ>ÀA}Ô?ºRËœ%]\:&D¾[,¦Ñ$ÃÐÎìn´cÓ5ÆÑ“ˆŽO[}=}á֍(N¡ñígµ€â9c&=}Ä®ÒξQ,öÔ?è³K'VL¡](ÂVÚCê0ø##{ºŸÿ3¡6ˆ®˜L(¡mÕ"ÕlÆzŽÉؚÌÝ;Aª¸_Û
ÕñXã0î|ò IUÂâwļÃú®ž‚[,ÊZH«§/nŽ’Päõ]eÿõuóšuqú´Å‘³’n=}¸@Ö,–ñ«À7¸£Å½ïoàõ‹› .®—<òò£àzÏq=}þõ–aé¼ù^Қž\¡Êá䄮ù”!MGÓ&„ adePõUሞßá=M	tï¸
+¿.Ç_ò$U+å¯
+w§ÆËp;Ÿt'QŽ$2Œ%$}­¬”ˆ ƒ€^(f%eŸ_0^ Ò¯°j¸ƒkª2{™m4‹c™•@U4N-LCæª!˜3gâùㄾFm¬EÇt‹îÏ6’Þ¤•äxN8‘a©Y(O}=}ˆŽ­ÔžWñµ„Öê= W‰¹5(—¹~€o»›%V´¼ÒJÓ°ú:—‚Îų§0V÷zî!
°¦Œ¡øðÃL!¦]èdˆ< ÛN´= C¤(Æý>„ñmÇs=}ïû&NK<ë‚'»éŒ_È!ôâ[õ³"¸ÐNV캪6­°Â*v=}7%ÇHßDÌ/2Þ= 5ŽßK9'ë„n"?¿lØdmçþ¼S3µ­¡BÁÞø|4ìX6!ôE¢z@ù}ï„<|à@T¢#\âC‰ËêéÙdU萮8ÂrãÚ·AÙvqŠ¤A4ÌÈAäv¤ Ä,½ÛVq^ºÞéçÐ3'Á69÷[΂xÈ»áT•“yþΙÍeúî<=}ÕØq¿Šñ²9Œy×m‡²cžàSÀŠÌëx—écŒ¢b9¤ž¡1c7ÈHD À!xÚÁáò-[xÚ¡xÚÁ¥Å;úxÚÁ¥Å;zxÚ¦Â:z˜ÚÁ¥ÇëŠîAÓûäd¢í"äü;ö'¦&Úlvs¥æ~cQ±¡K¤ÐáXÕnIÆÛ!£à†¿N;Ý&T,){†lH:_}3 Ãø½óÿ{ÎÝxöD= eËjv)j-KtÚF7À
›ÍãъòeS³
1Ð{!ëwH«1¬È¸Øýi¸0mOPüéyMmOXÂh…¡º<¡!øÎÀ+ÓÿÀU!4Ž¹nð?4¬²ÔŒj FØ»ãw;pÃøÐ"ËT'b[[ݹ?°#O·Õ·Š™O%·¹¾É„”³ä,}èÚöÝvýÝsƒÁÝÑ*z¼wô†ŒõÆãúۊ³~tž±üO᱊Ë2¸[
+ÁÔ(û6ùé2oeˆ•Åê½úLÁVqR ÔI7ÐHh=M*àCY¬Ñˆ­p#¸ÞYvGà¹8	‚<ˆˆco[³žKiRGŸj&õՕu6:“ÿ¹C;´ÕÝèÂËj–ÒOƒõ*W±[Ōk¤íknXâ±vRa¢¯IC¶Ñh‘}£]ÆãZµ*StÂm”‰Ôk™øòÖ¾
Ö¯w<
+
­™¥ñͪÊw)*èќ;fy>6z'ÚsFaãì(¶õêÁöcŽÔ@n“i±c'ëA>Q“оñBù$JCv…b9|U3„™q³Ø8:Lw(ô¾îMàaSåÁ®bGÎβÖÍÞ= 
+<Ò!¯É."îRUéwºÌÊaq_Ë’;e]¼.ã1ØÄ~–qØ´•¨
+©pz½¬“ÓsÐü¹Ø:2R%3˜§ü+ f„=}?@Õ,zèz%ø팋aj*Mô…ÈÍœ$w§îyfhEáeD¬
+‘ÿ™t‡áоÁÚãèV¦e֚>€ŽI[Bë+V†(mÀ®TBã:ê{AÓà½WWºÎ.®yj{µ¶y/5–kٝ׹wŸð¾ÒäÄ-¦ pþ*-+i} Ë}}ÈiÅa<ûceÒ¢]ù•á¾vÿ¡•+øtÂçm=}qI7hyP™”Ä‘H±ÒlظjuO–Ô×ûÊ86
+%W=MñàÎ{_bØÓçõÓÿ%$|Dì£ZL3F…8‹VãWu";¼×H°×kyPøÑâëpƒ®=M1¿ëAp:UŠ>’—2{íØíwK1-<–êJÜÌùksöK&›êBˆ.
3_g§%ÄŊBƉ_®Õ¡o8C@Ao= „#±®Pïf|§áÓñØ)¿G4¦ÎVYÿjMa›9)õç[\Ý]= QߟÔ\pnœ,ra7©ô35‚Œ õH¬mµ[ÁœÏ¿†¨îÂëq灸ñïy>’‚…°ã¨áP“4ˆú¬PiŠ;Ò_çÂø^büZ
°d!j©^/i¼CpÏb0üö¬—FE´ôU$­i‚Àⴞv+)ñ×"¢:ŒË=M››¦.Ur{	åŽ=MÕ
+IݞFÆFÄÄãç©Tùýl=}<Azào.û“y2‚†ˆš£x„–€á3y‚hUuj½ù¹‘Ÿc-¦„&í-tüßùo¹ÊË•ElßµÕx¬î‚fF­eþ
|)¬æ«Ô¬æ=}f[›8mí ‹ÝÁ¡Þ¼]"ƒdÃ>ŒPÅߗž?F’^ßÁ‰ŒV䕬վF— ¶»,ŸL±>4"=}8žº¦Á…Øš‹™ØJ:‰Ø¹J%ã­JÙ/WužØ©*ã¥<^|M½©­
S3–‹…<sd#ÖXæ<‡@ÍÃNÚÿõú^úÑ]þ•¦’ÀÿÓ³ÜÃBåç¥ð	”òS,çT à@ àÖd"r°¦”öFUlë–ü9ƅ[,óÒ=}˜¦‰ùîùƪÌ(‚@zØ[«+ì=}æý…ûÔQ9iŕí)X&7‚­Ø%µ‘²´‰Ã_	@´ê>ìÎÝc {À·–ÖdzC /zïç %ZƒzßÔ,NØ/S”w,¥¬$†µ²*¬^S=}ÆØ ã:i›È#eEȬŒÍþ	õ{ɂ;^c÷Ô§ìgÁ°^ºø»
´€ömì‘éŽÆxÿ%3ˆ&.·‹ɄƱl·Ó=}-p,Cóó£l[dNÆT¥ŒR³=M¾¹’5٘ýb6‹Ý„…r•¸MéWB$Á‰/í1—ðm¿ÁOñԍX™Lþ4¾k–K½É¢PgsáäÜðSö¤ö9ÍKzotõ•= ó}O,LàænГ6®=M›^5;{°fÚ['Œ[Ö^Äýª¯Í´M"&¸´¥øM½&}þý›Ÿç;ÇȬvyÀÆV= mFyÖpc½“o(ˆ±Ò•k.Óv%Ì
ôpÚvÜ¢®Â5?ƒI].íý¹2RúHåÑ':ô¦ƒˆ	„Tž°‚éåXñë(ƒšxƒj¬3œ™B‘¦_‚×'ƒ~’H>¶ãðy©'+XžÅÜËXùêñ·œw¹žÏ€-	¨”	rF}“tÐrJlxËã¶&¹Ð?Ðl“qýànïm.^‰Î\RðÐÄÉ€š˜?ÒÔ]hûîqç¯WH÷CJvÞFñîB‘Ù®Ô|Z@ä}#–†Pü€t'‡-F€:¿&…¨8§F"¶Q+àƒ-‘æ„U|ÎÍ£ùu+”y‹£¶ý.Ø¢Z—\:
+-ï*°s .ç$áås¦.
+Á8„9¦cRY‚Œ4Uh©Ñ‘j|:èÑô½ƒ9®MY<¥<݊X®W“œˆ˜·cm#ôU…	»UDaI	²ùlZùq‰ä¨R‰Í³Î 'SA¹g(ò©bÕÿKáFÒm¸\Å?˼â®E7g6ö‘3«úå6][éæ‹LÁóƒöó]ct5Ëig×nˆò¦Ï	¦r·îêÆr= Ö´”"6s´×QÙÇøñúõ^”mÄDÏ)ûÈåRªÚFÅágé
ôIQ¨ÃæKė_¥Ì®‡ð¾=}y4äò
-I¿= 9Õß»BrºÈùÁ=}ýôQ÷ÃKì|Õ0€ó+öËÔq\›@ªÕ§brZ"/O­b Xð iðÝQ53Ú>Úm¶= Ô­pî<ŠS e¨ö}ªJ=M›EÖü|£Šgƒ”ˆUáfÙY¤"kˆï|¯V—{ôeøÃ~gø‘æhKwŒ=}®G>ÖⱗþZç7Ûй_žõ'@bS(õzáh)f[9廊mHšˆ¦až^,Çx”s®35ðúÃàíŠ%*J6ÎdŽÆ2íŠ<e<KìX’ãXŽ<X—©ƒö#®
+\.«Ï<ÕÅ<Sž‘Z.‰3ç½6.ÃV®YŸYrtÊtúƒOˆê†óð?H}ÿ[³´u>µ8[¶iä7•Åï^¸iOœ¯°nزHõÒè·œKÕ8øˆºB2RF;*gÚ(sœW+ÿÒ(×½1ú9ý4ŠW†)¯‚_+g(¯ZÒe]yóÔAL‘÷XT«eE탱>Ëxq‹Ö5¾ŒÜ±¼ÕtŒ…£j¸öì‹‘ŠìYÒM©õŠþ‚ov…Ð7¹ùŒ—^«P↘·Ò韸¬Vó±~Ÿ	j‘î]p‡zž—0%d¯À!ƒHù—2	Œ½n2å”Ųh›þ"Ò¬Sā÷ð¿4sÑyo&Zñå"/ú²
oϤò͗;HûŽ+-ÊùnÎq1D»2c½þÆ܍	H[lc»¯q¿Û²_‡ˆ±ù%Š¼²= 
+ýNóÈҋÄL¹"³óÈù›”à#Ú3¤†ŽíÁÄ-ï	»5I{ºÙ	CEj×B+Ȕo)U<ÉÀǟr€b-9üˆÀK—zhÿ~-§¼úƒ­‹g(½@¢n>ýàm3‰îýÑâÞGæzæhÞðV§ïT FÂaÐ<^$¯U¦AЖX<)í›Úؔ‚TTµƒñ†R>NsF‚ŒÛé8œ*F>1¦ý”?]3‰_†Áù˜Ýv?õÅhØL€£9aö"H/樂¦!Ì>ï§Ú¥(Ò(
kÀI|L¶Á÷Óð…KÑìJLÒ&¦®‹ÑIí(åz‡†¢aÑƘù,#L0Þì2ÞÁvÐZ‰­5/öãË-D•Öð„/‘o'8•¤…GŒ=M¬gMî8}
+¢ï|–é-“Bü
„¡×s]1û©ìû~е›Cˆ¶/·€!캧w_àVƒ DG%Àª"Aî,düª@¸_sQ,æݬ€¼¼E£‰9dýcðE@$WcВfHêCc‘›HB†¦
ÆP8¦áÉÏ<}mP]H§{Þ
+ýc!éb%æ§J= ‘*äÜs= o})ãIj48IQXd©îg´Ø³Â¤	{EJHÑs«ã‚T§Ý´CE§â®¶_çí<­ÛXfå’,ªÈÚî‘Ng3.<fX–œpá±sÌj{îÑߺuœMçîš.ïf®ÚF.Ý6®ùÍ<=MúX®Êë
̒jEgÅpÅfÅeÿ¯ÀIó‹ýÆA³¹NŽH†›‹¯
+'µ	wÅjœ;íDCºCDV3EZ›E=}ËiÌ	O½Ë0iÕ;jÛ<“±¶^ùL=MKùK9‰oՄ	.̉ïøOòÀOUò¬•ã¨~â[ñpA^•Ü
¾¾€P‡Þ°Áßf¸¹€C?6lû‘
Óï–Ax¬PÁa€â)áG¢ð_ªp÷Em3pÈ›FœûnXºcÖÖjÎýHLú¾}^ó¹ÅÎ÷‚ˇn³&ÒB:î›­†ÅÉ3ùÂQóyv¢¸ùÎ!ËÓ°¥~æ~v΅_õMxÊä®­¨”…}ºœ¸õ69ûÂÝ¡Uö†»ªÖÓ^%1LÖZ¦-
+Ú·%«.Ò+®gùÉG¸‰‰¶‚’¡Åüo€ëø5Öá-v„ºê~Tý…ÝO^€'½R¹ÑI3—îƒÂWŒ
+ç¯lWöppäI‡:CŸQýU•}lSótC÷!=}È^s½2W–ÁÍð@ÿ.ýéE×Gù<cKñ¤µ#ÉdT¤#¦óG•=}ûPªþ:k_G°Â†Ríˆ3±¿ölºÌS»l%)µxPšÞ.•¨SÀÀ+‰p¯ÅtؘY]þު·Ïųm¨û¹3Î{qÞÆMm—•ÀEyîÄI’G¯ã~„ùõ¯Ò¡´pCÃ^’*剆
+fÚãW³åâÍôÑç–ÚŽ'¹½-Çú hrN¨ÆÒ[‰šåNz±Ñ§.ÃÏ'ˆ
êc„U	(-÷Xf»ê¯3ï]a:·oòÇ	ÒLÅX¼ÇÉKNrw˜Âñ©ÈEúÿ*½•µÊÞG§»ô6}ݽjÁwóò«—‰é””^ehZQ¯IZ\³Òׅs|ªü¬z+:àÅR¿fWôâÿ±	æ/T™Gù¥f#Cž°g”AÉNÆ/jÉpY‰?ÏDdzõ´7ipbrM‰ËGfZ½öl÷Õò'Ÿ‰x¡:¾5Ö£‰‘›üH	 Å=}Æl=}Ûë[aÓÂSu”áªÎèJ¦^:xÆ©#Ez˜rô=}Û*šÀ{oœü+f?šƒ»^˜ÒOҒÕá¾£nfŸ$Æ.à‹#<_(n-æ­ãcpѓH"×-ãÐ
>¡÷–CÁTö¡ãB}Œ2¯âˑÁR€,ô[¯å§ºÑèV.õÙQ
+ö$¾º¨7±³PGRòLÇ &s˜¼(KÔÆATÌê»®÷†€Þ¹(-¸¥UšX•V*Uä˜zDæޛð[Da¯4­+%ˆ/{íU£@ú+Zìaà¬Ù¸ýŽ>Žîca#œÕ»¯37%Hj~¨Ãªeˆ½Ó8½[LaEޙIZíUdŒËAþDOcÜÿ’,¹Ø"ƒÞÏà#KñŠØ*¹ËPòŠÓy£ý÷”
+zàù(îݬQHå8Œ÷h‡3Øæ¹ v¸€ÕI„Q†Tù<¯ÒìQýé"CõLÑÀEÖmÕb#KVÕ¦‹ÙUaã&§ŒÐŠ¬M¶}ÖeÆä.¯SА©]6]ÕgöŠ'\ɱC<<qÓê)}“½Š±Sÿ“¦Ûø%§3}Ðf÷5›ÛâÆ«;²…ŽXv¦¾æ³®Ó3]°Ý÷#{z\âî3÷>›bTñ+ÃÜps	¥YëÝQAî;÷[»½/NÇ€¬ÖO,\œñMã7äõ/ŽÉžHóç+Ÿ”ݯzõ›Ž ”C"ð²7 #£#q‹;¨a"ñÅ\0	³£Ðø[(ÑiaèÊ*bĀ:,ÃSáH2,¡R¼Mã=}R”ØKcï:9Tæ¥Àþ\$Bc°[$ªê0L92ªÞkc]H4÷o¦‚‡ŽH¢
+c
^B,^«ã0=}¦´po-£·PôÖ·äˆYœ7é

Bç¾=}’´¾³ã±<Â"YæÔsàŒÈ"¹‚%‹5têV%¤x%ütÝ¿J°|À= d³
+ýc©™Ã´¸Dvb†Èäd‹E6H±Óq©¬ýj¬_ÅdçËjÌëpb¥ruß2ÓKµøüĤ‘‡®Ä^<›§“”¾èñm¯ä<®üÅ<Û­Xž{‘t[‘d™“\-ØîY,֓èÃY‘ô?
€GYäYj3Xö~°E“¸ÿˆix¨ƒ{6gàs®OYî“ôÜðÈê¹
+Wu™%ÊB®â2u¾R®ê*®ÔJ.÷¿<•ßX<üÌ
ÈÊðÈùàñÆÚ±h3ç҆®*5™«JߪwKg¾êÄV®0µûJJ3’8ÉètËDÉüwésÊrÆkÅnÅiÅuÅ=MŸýM׌ö =M:Ó߅Æï–O…-gåÉÁ…!—•õìå=MB+ßE
+»¾ì÷7fÊi&ø·D=M4iD9j~ý‘±äžþL©QþK1]XŸ(¢' Q¢H*€ÕûV–ˍû֛֍û֍û֍[
˜—‘o2ÙÄrN”gWÇ[¹)ý¿ï|íNoúáöN^ê4ìïQ‘[Œˆ÷‹öÞ7›„Cê6ÆèRIŠÌ~h¯E=MS‡WWXÐO×]ùª°@s,{‘K­ÝàöuÑۜÍÌ 3»= ƱþYԜBÚО%MÜÔ®d´×°˜Nz@½~ìqoöIZ™±Z}ð¡äôX	Y͘®"RßrìÇßäÍ2ÄÉÜÔÇT±ÇLE…Án‹Õ‰§!•*»ð´R+Zû¶Æ[rKWúY
+e&nÔ“(‰<ªÄe“hÛO©6Ödzœ.•ïIÂÛ§êés-ZVrï;ßÁ´ajÖ9'3±êÆ	óR3e9“€;R?¹«â‰IîÙÌ ÔŠÌ©{§y…;‘ƒ”+êW= ôýý´û§ñ'їq<Ýçaâ&¸[T*~½ceüeŒ\–5fNW™÷=}Œ“߯ج߉ï°5^þ?ñKJwdw?ÌQáËÏ"YA"õyØ\L!¥–IüÌ·¡nµ<~tJàÖz)ÿ;uúŦUU;—W¢¯QÁAöW¦Á®I"íqq‰)ÙVHX§Ÿß=}ïö)%…NÐx=M®¾˜ˆ­3•Þ°X0 •‚ax²>¢W»ãQaX2ýÙñXžD.©Ú)Ð?jbÛt¼kkçð©LÛø¶œ¹4ª2ôO£êjìQϦZh™W= 
|Sb“zÑ{'|F•ÍyOæ(¢' Ð"  ¢ù֍ûÝ|Ӎû֍û֍[ûÖ=M(
+(,ì*<ßc(<ÀMj÷\QœÞ©C8hR˜Å4®©ò<–±…aYŠŠI:Ìè¤j¬ösA…³J)…Š?Âaä›m~ùŠ“Ä.ªòštÍôGÄâ )fnTÆÃ×I&ì؏áÝ7¶Ø{sè&W7[Ò>ùsè7n$ÛÐ
ÓKfÝýQl€=MXOÜêÜ	×ü·×Œ]:à5+ðš9dn¿0ú’c¹ÒB<#ÅhìfÑ\ÄWŠùˆ}ý/“½!<ŸY°^Ã&3úQ¤õ§q7R¢ËÅCY’€TÜæ·W®ç›FÐî‹2‹*G“tÄcƓԞ&Ïîâä<ÜQœþN¨Û‚5Oû公9Ó¢ÞzË8¾Øºu§÷ˆðšÚuVT›3óŒæâ+ÓµÖqßµMiû8Š[×ï=M€½DïøåýžÛ1ü0ÏÛ73ñ´·=MãIž_uÏ/€–@‘.ñÔP'F?
|ßÃ8<cõXKtnðÏ$§Jn2¶–ªÉ_ns,Ewï2•<Ê{ï3Ö"¹sO²Q2!±·1Ù¢Ýýu¾;|²•ê厐Ø&çKŽò¼“«g©×.Ž?ò>ʗÓò#Bn^„¡gœû¸¿ÐsÒ_ƒó¬Lº¢ÛÃ~\5}Ã:¦™á±ŸgÍ›Ô|_Ðá
CvV¿pÔ¬Ûé7n8œåc;*zÿQráLµ¿´Kè
ÖúEÑvB:'8å‚ñ1­ƒÐh\菱b¥$úš2iiBÍG9ÁG¥ÞbJϤTÂdRˆ6éˈ6åҙF¾cªdNÊr™l·îGnƠᒥ´ê7‘hѸžêEʶòÌvf¾fY	z5„trÅw¥ÄUöæU,Tͅݙ=}¯LIюàøαq.m<–Š·k+ýŽÍXšÖQêÛ½•Þ=}¼~€7ï£Ú™:òãõP¡Ï†B)¢'àX4$ ¢Ñ{«øœÑ“yûÞʍۭ‹û֍û¾Á•¹*3]t±ÍpEôk­KõøÍnóŠ•T%:ì{á§p³e‹UQ0‰ÁŒö‚Óh»/íúب•¨ŽñAyÌkt«N.‚]¾WÑ|ÄofÓ^w¤&ÏUÀs€èõ¦¨¬hy…dÒ·Q¢5æܗW	r3b}m‰y„ªÆ³9)íÈÓSǖÖYÑv6¸†á\skŒFyòïàªöÌøυíÆy·ª-žãxõ&Ó!քÞÓÅʧ=}Iïð²ùÓÎ]fU.4‘À‡±C•Ç<萂çžGœ¼±‘†€°+µMN8™ÙR•±K¯Œüð»
+æo]—–ï½¼?Ì	á7><±˜R¦Gvå~XåÄd¦Œæ_৶µ^ܕ0‹Ê “ZbÚ­0’Ý°*1׏ª¸tHfиˆâúgß¹žŒò‡PŸ¦ßgÕQ ´+!ÄÇ&Â×E°‘¢@®í-°žPC§%	eP^UAx½,—lH>MÁDú§_V¬ÖOœµ¥bXû3C¨ÀêQ2æf’sD¢ÆH"ngBJººµñ¬Q­Á†x,ï?å@N¨å•›Lg]¿8gàX~õa=M1810o˜î®g}¾à£³)/i„üd¶ÉD1Ok‚üD7°¬€fRãÞFSÔF%ÝI¬hÄ2Lµ©ù‰lkCùD½eÝóyžN½Â,zƅð^£ªÂlz÷…ÒæT«¼~yì]µåD‘VÂÑù˜¼me’.ï6S'µª|ú°k§‘>ÃÚ	= >†î¼;´oäٜ2e%Ü!IW*¨-I
+ØbŒ7CÒ¨mNÂ=Mq1cƒª™QÅ8µç匮Nᄒ)&/jx;~êÑżÚyjq= 9£ç´±˜Á¬6ï’Ö,HgšØ¼-ö5L·w0ÚÙ"¥vEñEµÔOËûj¦råÙu<Ýze£wU“tó—wUO•‹ðNɁÿÂ:<¿õ€3rë
ÕÜ^të‘Zòë°LÎãi=}C9ZÀ>»½´ÈW0¼ñ= ä&n¿€¢mCOÊ;™ÞرÑ/:YýäúNm({»èšý¤À¤¾DyOᣤê0I³’Ý´7Č(´
øk¦—»¬ï…Ø(8ëLzJMYë=M4øµJ(¼Â‘%‰zjrµ\:ÌdØ~©é+?&ä!ªÍM¨Â;Սûæ΍û®œqû֍û֍ûV‡®¹´Ñ;z”ƒøŽ“Ô;É‘Þ¸¯¢?¥؜åg昞wSwÙÚüïæûžªE.ðƊ ¼JàÔ!öý,€ä/’Þœ°{†°ñ¢\Z7
A¦7*‘Åc¨sƒb$—§xRäìô*÷(ƒ™zî/”¸Œ_âäî1ŠÃ(šeøØTbÅ+1š6ŝ®H:déý]jÂ%q6½¨c´‰,Bµ-V&-¶­SÈÓõ€£yºôéÒÜÞé6÷乆’—·ém®‡qC·¥ÌƒñâИ^îÂàf«·MîœÑè»êÆl‰»_zû¨>V‡øÿ³¦mç߸êAei§!í<6Ù.æ[DxðôO^—h8ãŏ6·}fՖéMŸNvÙÔY
+ÞkÖÿ\RÇØqðÁM¯¡½]ü¾>¹F™¬|Ñ	°çÌ{>u^™L¯KX»eÐÉÔÀmcឿ™Oáå)¢^ë$ϖ+ò}4DœFX»Äb‚i²žÅEUiN•´ž=McE	‡h.β4üK	’~òÁDë‡éú8ªrIÒväcÑ×ÖŒ;åÀЂŠo¥:ÉèRsQ¥–åûƒªSw5]¿HޜrtwóJуfí¯œº¡ˆŽõðäˆÆÇÓÌÁQšŠ-õ„¿ÄIWo³›µvm£ºG‡TùŽˆj]ö„žÇÙc³=Mš( b) PŒûìÖï֍ûŽGû֍û֍û–íU<Þëúˆy/¡øŸ'Òe-Ä®?R…€Žæ= ü¡Îe"Kê&Öu+ìË?ˆüB“= ¡k#Ÿ¬(ä¸0fü= ¡¿ö'º+Ìþ;ؐD”€Å= ß»¡/"‹¾Yï'Â
‡‚ìW‚îo‚ü?ÂùŸBa4Ñ[Ɯö©åiä§Édâ”B{†±Y§¨¶wüIœådÒò‚q™o5q˦8gŒˆ@–V1‹{¨qÍd–÷n‚žw±ÒǸùgœU= 49Lš,“ýCåºQ‚˜Q…²ˆ[u„½A~ì’=}“SkLxDÂL5½¶«cK友d•Î“£ˆÝi”øBâVq‘§hÓkœÕgŒûKz7±.ª5§¼¨øšôçå3³sÂø‰÷‘f¼\KÞ_O²0eOªº·dóëÂ5qÊHŸíßÞÿ0þ4[ÌÿM±Ö®xŠ5ª¯©ñ¶ÞxY?¨}¶Áx‹©>Yþ^LÊûF©ˆˆ=MÛǨ-ӃûS±ïZú2ی_]7ÉͲ•Ñ‰ÖõNû§Oä¶ðÒziˍMͧ-ÓiV÷vøfû‰'¸½Ñ«–õŽø=}ۇ/=M±]ÑÇÏ=MÍ÷ÝD(> ã¦âP î֍ûkþí֍ûVúÆ֍û֍ûÖýÛ¸q×y+ƒ—¼©*ü
wً‡}Ûîî ?u[÷&L,§|œ§èGk؂ótNœ	@þ
l~pýä_•[á-Ÿê¯L1
¿ýt
ƒl1û]ÊñÓúœÎvþCˆXSÛ_¹)ßӓSöÐñ‹–R;g™†š>Z¶¬㶴ªSÍe*Ìs£½]‡èÄ/{QۏîìËê§y‹¦ÑŸb"ƒ®yL…–I[3pïìmÚøËAi™4]Û_¡®½½fsíÁ©eP™%u€]}(ýjFO9…ùgíS¯rüS4ÓRiÝeK*?²
ý·ôù¡öÀQhQr¬þÅi²o³LÝ{Àdª÷ôˆ®©6­óÃço¬‰u¡Y½Šc™.´ˆjˎ™qé2Ÿ:ò1lBY1HA¶L²³˜yZ½<µkVœ1]~nBqUôÙÚ©ÂTúɕfO
€xM:¦°Ö1°l9­nŠ^19úshƒZŽ
+ìâ<«ÙÝ ‰«‘È“9,¶Î¢ñÅÕXFß!Ê)»AV›[\N¨ÐŽé>xhg˜çA(®ÁÌDê_¼¥PBbõÎàˆ-ìëØ­ÂqÑQ؇x
+*vŸÿA
+G¨Ì¦Ôߐç8ž/ÛWÂ0þ(xa"ÊÿÅ0KF£X5Yˆ¸K€½¿2DRt€ûÆ&ÍyºXÝ{;qo”Q~u?Sã,qþ…¬{í°æ"½vèÖ¡DùÃ}äÊT‡ì=M¦ô_>X»%9î7rzX^H(qïbPV],®fBöG:ÇÖçaæQ!²»³‘èU5Þè= “˜6êNbÕR?£6¼r¬H§éÕJ”õ€Ôe]²NV
âvèšÖÛNÌ|ÿ+ÁÆ?#$á#€5  = áŒûÖ=M·ûÓ=}^ҍƒÖû֍û—±šÒæÍ7zS
™¾vÅ!”$-áÚáÄ9.ääl[¼þÝgC8åÙñ$Ȭ…påXKn€råduFĞ*¢‰]#Ù×SÙ^‘Vk­0َ>Û¢òbìÊ72ÎïxfÓ’DîÍdہ5v÷Z–ÅÍGáfÆLø쮸MŒ0Å“á–ÞD=MÀN¶úã
+êÝõÿ¯
Å£¬9›¸ñgØ8K/¿@žèI–g½áÓ\ߐ¾«SOò|š©;®w:?oþŒ)ª;Dù1J­ÄÖLgèóÄBâÅêØ/rEÀd­OÁ:LÔð	çû8þÞ뻋bö?0ƒØ^5?>@A¡/>ñw¸Ùºo¸Ï´¡*ï(·™®Êô+
+E~’~5ŸE~C&Ÿ	×8éÝc~	]£õ_gjå¿xSÛþž¡9í0ó|–a¸oFd‚‡wqçj¦锍zw
+˜¯N¢+š\rög
+©!ӟ;Ž‹äPƒdF–ºÂWñ<ñz+¶¿Ôämåª	Ìٌ£z¤MwK=M¸]â!u®ÌY䝡Sú}9ªŒÙ;c瘂«GIr~”ÝÆõõ§ðbtfsÒ] J¡|7äñè€æ—¥€×B¬ù2
h«ŽˆD÷Û¸ØV&¥xšåÑTM¾Eƒ2‰[²äÏ7é,o
€¯TN°î&&¥N¹hԄÙQ§€aNö™h—sÒÓ°mï«X?~ìîqÅÔ¼OcÄ}nx‘%¥KË(7vC.ÌÁ…„=}ûÎö“ìÌ¡eM­d‹†ë6ô«zqÿðîÆw=}¤Æ—RÒ» ,ba ˆӍ{èV¶‹ëÖ]ûÖ=MºûÖÍÛ§i£¸=}\(›£ÙW‘(.ácø€HÛÆ,ãIœ8/¿.çˆö(æ¯= ýhÎM9åŸyÃxÄT:­ƒ˜~Q&—ãÑù[.ÉΑxØ(¢@Ï$¥ˆ/4B=MÉP‚+eî6ásc4¡=}‚d—¨q
?R÷æãÄ)ܪ¿ ÐdfŽ»ä¥¶i(Ûn†Öì4ÔÇnr
+t´õÇA҇Z=M£†Ð	,R¾ïD…õL¶öîÂð‘VmR“ØX‹N+Òÿ„>ñ‡ƒ_ž!YI+ØÇÓ°Óç6IÜ8©äåŒõz¢öñŨ«LƒR|”·“ô*þl|i…öj\ív1Ÿ™UÛ΁œå:ÖÛÎã•Í{oh÷š%Œ€¡fî?ødÙè†BRWS€Ù%»{™Ü’;Î=}ûø:ؽ¹ê@|¼êÉ2ä¶iPük2½Wr\ýÕ#G
½Ìîý©ÀóN˜Ö»€©]8)EH›Oû½Q垶=M\ Åa„«.æ0e?/ƒ’(–S¯Rð4·àƒXˆ?Çú)ô÷½¨s…¾büT³_¼aøyžî³cÇTÚшÓZ¯+øßhìkHÖ}žì…LÍÏPõuÊ.ƒ"9„„0k³eðZGp–Fa;ŽqA”»Óu×1+ÙãDÛüœ™¯¡ƒI| ÑÃ>ÁA{">¡	ƒt^éÇ̚æláÈô\‡‹ô+öYÞÉKZ…~3J¦ÔùyV=}±¥)œoÂõ'֞hûÊo\Ôäxñïd¬s뇼…ß0»%Á]™K]«ÐQµΠ\G_ê“Ñi>E9%²ó4øÞw±èª\{Τص2kä´yÇÀìÅN…¼É@rÈ¢)uDBt9Ñu­:/U:ÈC‚ÈîÑ:˜Ÿô€eË&q×T²Ç©‘M.gˆ‘…»VºþúNð×¹.‘BÚ\vô…m¿Nâo8}ÅçÌë<oóç !¢-ðù„èšocz;1‹†d°¸QiJæ.Va
+Õ)Ö­Fì܅ªŸ¡I÷ï¸ÑJᬛìOà¼;M؉¡ûbkdÍLñ¾„傍KÒg{ƒå:Å>‹¾ù€t‡cø-{æ4ú’sú®ü„[Ž?ÔgPü¾ˆ‘'LžZÀÜö1u—g6Z±†=Mäô‰îÜVÆnø¥·ÊNl:
jGwl›|™â­mŽœÙ®¥[™÷\x²¡ºÔGcò\ñX
+åªxOª˜2­ÂØ/OŸŽÃOšÞÞ$ÌÃÿõ¯Ã«×‡PæÉIÿ9Ž½(Ñ?¸‰«àoþÊdžOÌž1_W"?Ÿ“ÑW~uç?œ¾…—Ê>ãÜ?÷&ÐÁJ IW#1L+ddF¨™eaÞ<ìë܀ž¼/„–(҇cij/àÉPrsâ؛\<
Đb®d@7?ác±L¯­„¡HæfgAÐOº	±ñŒú3ãõ8—å²>:ë¼½‘Ü-©Ã= J¾CádkFLH¡‚©d^&FÒ= B©ì Dä³Y?°ìR4f&ÄpcJùriF­´Ÿ‰³nߔ¤äSx?°¡¬˜FF!¹„©‡QKP«g2ùd$†Ó= R'ÕÀ<ÚE“™4¼kÍt>¯bþ±¯Šˆ^“–508v b$C*ÛǨDZeÌøwlctQk8sâ±£Åì«KÅp9Y…[r®}‚Y:çJ˜¿|áã3µèÆv’t5ò	lUSËÙB}ãÍ:¾¼ÏcŽM
+7ÐèÏã’]Á¥„ÀÉØ¡QÒ­ìM‹¤;mhwTvSúuíØÿ‰AÚÆ¥›Í,͏…ãVÖV֑‘[¯ºûqžú¡•‹'_¾—2ÿþiëNz[Û8Æ;ñ¾Ž†Üq/K_ҎÀ·-¿xWØ¿uyT” 	’#¯@˜ Œ#  @xçÕÍøӍû֍û֍ûåŒû֗WJà¯ßeVì¯ÇçÈ9喝gS¤_¡A!ÔJ9àù±!ˆn%Pj0è£r¡Øf'R
”@—¥aê$ñ‹l0§î$1H.Ƙù€¦®-†ù€^ªcèN7bՑA,ì-¥dàɒ"¾®3¿G@nJd}~¨ƒÜ0¤4³ªHv~dî˜1Ö\1’ɸè‚ž¬3“Kw쎩¤éDT=}Gá¸K
ËxêÒrÚ¯µÂ]K¶hæèRRԃ„¼]MÃÉP´OÅb9RJ4áÉpf¥¤
wR¬ÎCâ؛\¬‚a
LI6î¯Á
´Y:îT(Î4®@‚$E.eð$Ó*eÒßDÙBÙS²'H>®ÎHnŸ­‚Ó]ºiýÉÕM:ç爸‚øÿI¦Î;ƒhŸ3ã)Lmûæ••Lc¾å2Ȩƒ= XþL­Ã£XÖÆåCˆ8oÕìØ9oaœ"ŸŠF°UC!NEpUB±Úµ2ÉSA±ªÙ©ØeiD´jD?m‚ÀR®¼„>k†¾„rßEÓþ¶¢Ñ‹*ËVÅ0F¥¾ºt*zŲØBµš/s¹²¶æ‰üº³æÛˉœ«j“”¾nhGŒZK$9”K¾¡h&Ï.„P‡&V‡FGۅrŽ“FG~‡‚q‡QÕe6o·„Ø»e»äŒ†õì†ïôŒ+ÒÙB¶“Þļ£cL\HÇoYN§¢/}4LøÀàba~Ö²j­µ¼¸ÇdŸméÈh5·JȨ<Ñ5MÉqSاºþ»õTÅFgÁaòdãù™:~õ°<Á…sYMÖ±zö>ö2kk;ۮͽ”Ü~ÃCÑ.‹Ê¾âÕ4ºÊg»Çg<‚F&Qp–»¡wÏ-w8ûèhYfN~T²MUñÒ¤©ù#mý…BÝ©œÕ¹cmíL¾‡Æë…S†¹¥'EL,>ˆAŒ·¥)LrzÉõøêÒùv¾×B4ùèL‚cóçfæ6;¢7VŽÅûytûnµé–^¾ÒS¿½Ÿ.'=M[ZXÙâa=}'Ž”H„èpGãX	þiuÅ«ô¦NŽl—QD÷e| »™NWÒnŽúϐÓ¶»ï1>²k›Ð,€ÿaòcpÚ·“Uܬ:eŸäë
Ï~*œŒˆcPëgå\?9*'àX  ¨í֍ûŽ֍ƒÖûÖ}í֍û֑h¦Æo€y³$²úEЎ‘"sOG0ë±hu2ÙôM±®Ë3”K±˜žXB¥aÙ1Z\ ¡e$u)(/4ðLyà×ç"v47²È5’Ð°fÉbF_5’ͤ¨üZ1Õ¦¨ˆ¶JÂs1%j¨ÙÇ1S—°8aÒ¸“¯äˆ«jhujèú¢”änD,K@…¸djç¾rDËńÞAEIÇ,e¢¬3=}…T}Lƒò™97Rèûpnñȼ2S„[JþwYëÊIPZ5\?ÃÀý.%÷~HÈwriwÕ²¥´ÄÍ»j¶tñÓŪF=Mtü»ËÂ)5?ÞːuwÓáÁHU™×ÊIdm©â:¨U¼
+ʁ2-uî‰hÿÕÕ¬‹YSfkڍzj]ñrÁ°®B=}OZ	xß= §Ä®Wÿ”ÔÏÂÒyoµAš¢;¬ÜɇzV#ƒ;;ˆ7Rðˆ²¡Ç[-,›†@{Cݤfî”P²—αg¬ˆ^8±·Qqk…g/3ikl8o»Øí¤Æ²¹µšSOºIÒòl͆ŠR³ßÊ¥›f+“{ˆÑêâÁ6ºÒPÕªµK&K9yIÖâj±ÓvžÓ’Ê¢­:;µšúxßèf¹VšŸÐÑÃĽç2[ÿZøTóîÕݖv\Óê{“'#c.~­•@n‘PÆ£U9½ŒÏ	Dé„j_G΅n’¾”Ò£³êE|l2ÚØÿúeééN2×Úpü‘ñRÓ»BÕü|WÙ9ñçmÑåŽÆ?‘=Mµ;ia/Ý»›¸
P‡¤§±\Øï›Hõãr~tBO›~jm2jR	Ê·5ßÜLMƒÔì§Í½¯¼³ÌiqÚ¯%ߝœLÇÞì¯ÃÍ¿ød_¾„_MÏiãïÆò!„â §B!Š®.ð—} í‡"¼?jÁ@§»&¹*:0D@³/$éXh\‹¨­õcüv§üAäÇiAŽE¥x—Qd“¨¬e㬋6ÇS¬Ù¸‰ãú=}ô½P§¦yyNbg¤’Á(û§fˆÑLâ£1^_¬pWs4sÅH>i4}Dj
q~M«R€´º/ÃÌê0C‡¥8–¬‘¡8Ë'åøØPæÜýQÚüªq‡¬Kåd»åم«óÒg¼
óÄFƒX<À ê"@Ú»;'ùöí֍œ^†û֍û֍ûÖQ¾.¼Zó¡óÏZÐUÆãì.JX\‹ðÑß¾’8‘ýû7§S©|î–ù|ý…¨r’ÈëÝ¥Ná^·[×|ªž—	³äƒ…>¯#õ]™>ë&›”»±—×çŋ>M_™|¬³K»o*^«zӋÊï²-^ýnŸ“]‚ ³FnÁ 
+$,-#–,)Ø\Oæ® ƒ·"Ý)ˆ5]D†æ°Yåbrö/	Gcî--©^_Dû®°b7cÒß*©5eQ­€aaº¢å®@‘_¡¸FxÛn¸ýݟFØ>ÒJÓäKE©÷hRoir-µ½CYÓy2ÔDëCi¡¿²)5‘ÒHεt¬ŽÀèA4{'JÒîp,ÇXŸd1ÖBge¶8ºô	Tÿ‹uñ¸vºØ}T³gŠÂî÷ÔùÂyžr“¾û‡íŸÑ,ó9îWlɌÈôâä:ôp㣹¦ò,C/9}Sü›…˜ßa‚ëÁì¶åMµ‹y~×Õ
+ŠZâòœ®…íšëëc¶ä÷L¹¦å!pÈH&ãù֍û…ûÖ­Ë£…û֍û֍ûö»è=}ç
•Z§•%=}ºw–þôÁ/§/#<Šn–¸Ùô
–§¯G=}bÿ‘ö
H·M‘|¼”NI+،ËrÔ±ëÊîN±ÌkÍQNãÚÌxҝßëÆ+NÓ>Ú²G¼ç˜>FÝgø">a™¯;]R•ˆ›¬>ѐºç²…>s֙^qºç·Ç>Sߚ„«ÓZÞo²^Ž^¿]…œ^õiðúGsO¿¬®™[燊¿Îۜ‚½y˜ýGíS¿œ~§-H8GÀgÊ ÉY"v6+x{Y€~㠞=M#ÊY!q&&Œ97pƒnàÕµ!õ×'Œ^20	r= õ!ÿ$ì9«Èx3oQKÕâïÁHst×¢‚™}e	vª³ýbÖvÌ8Ê(Uiqž¾âÎrLøÆø’hÑ|¨¶‚âSeûoªl4׈Fðäjù´}3ÁÐÆsyí:ºŸ­U™û‹
+ò”Öº>ãTFŠJîñÄxΙÜqS‹¯Æ‘íí«Aü=}í½‡º*?U+Ÿ‹þfP„­ˆ´ô0ÄW¬è‰8yø€ë8zvS€ýòÐÉÓÁɃF¦aã,ÁG8šîT|x„h×æð‘ˁ^ãñ¦7,Ϗ:~^RüœøåPÏÁždk¬x¶=}©Ls{¾†Ö”ìƒÙ}ärƬ…–5ëZ¶¬mM-ûzŒwëDçRçz†,Ö¬8	RùrŠÖE‚ë±u6‡³EáNë
+£¶œGMOxrýÐ,ڏÙì²½Åõwëä_¶
¤q¥[‘bZѐAµÐCÃPU§ð^߰ŸÈÔPβ°ËƐÄÞpݹÚ­pÂÓÐÄÇ0ê7ŠªP™°†¤‹¼°œÊ°Öp’ÁpŠÙpÍ°†Ó0†Ç¿Ð¨ð´0¢ÐÊðÖ¡€¿)ß~+]_*Wß)e(âGí>"åh£@ Ï5û֍tŒûÖ=M”å֍û֍GïÖíÚM›æÍûì¦Ïß:’ÆRÔk€6㼦K,¯*;¾µP\L‹ØxéÐÃځZ,Í:8ÒTUœŒ‰xþîpÝÓáÁہr?ãO#•È
¯q&;‡¹„ˆ^ýЯ¦ÐÙ¦Š«,³·9®ÎRœx‡¨ù„hßýp€×Ážc©ã¦ç-‰o;Bï9þ~R<܆8Ÿëp¾AÁ
àscû·Zžƒxá°«
È£Á´«
ÀÛAÛׁ¾¿áKðpOôÐ^â<H8³„x#‘‡âWÇ´d®Tddl²µH±£èµ»M?
 ˜|¸øq¬8y²Èt¦¨Lg¼ÌhÏbÄÉn¼ÏiÔ§¾ÍkìŒÀØæäÆdª6äüvô×/ñÛ]‘×C±Ï+QÕ;Ô'±ÅWñÃOÑÕ_žÀ¦0µ§1]g0<Ѩóô$]_©˜U¥˜Ymì@Î;‘”6ю.Q…>ñ‰!q†1ã2r‚’yi|Íü‹¨å¨Š;(×­äÂídñÍäݍd×=}
+›Çšúmœß·¸×¯ Xh¤>ò¬gtHqXÑ$1“²ºX’¦¨[kT]oÌÙ= œÜh„Ýl”ÜÂùÏÊ‹ªßnÞiTÞe,ßmLÛc<Ú˛¨/)Ï'däcB	13÷ÇäOïôç“õ± 7¤kíªXºø¦{Â[Âæ›B'âwΟtíoºSq+
Cçß2Cß1E<(/ùhԕòŒîä9	šÎä)‰f¤é:—ÂÔ'pš™ÊŸ¹e„F–i‘?åjuÊôó~Ê3ÇÅx Ñsò'JnâÄo0lJ%Ë'^¤8H/ÄpHQw<Ŋ8ÑjÜÄfXÑb¼Ä”$Qc>i¦hÂÛ5?I5e¬¶ó2L…©1’p|D›¬†³e’m¢EŸLñ~ê9‘¶´‘ºaê2YC¿Ei*æ3m„ØL·|"De"qt:j?¹N¤\4g©°´©d^ÉLíÄǬ±YÒnë™ÙOämbDqrD1yÅÀ´±:òpzkw	OC„¢ì°™Òlöê6ùE'¸¼±«’mŽë™BOÕÜ·om¼äeüåsœäo"Dh¢EtâDbBEjÂEf‚En$Bh0aD'Í
O/PÅbßeIJœ”Ûr;¿zµOfË|š¦Ra HV4e!ŒÖûŽÿ]Ӎû֍û֍û֍ûl	$Ïúgýñ|yÙC‚¹áÝS¢wQ¿¯ñüáï^ç©™í_Ì0·^tK2M˜Kî»7ö®Ô4‹®–¢1ƒy«¹¹r¶Ôˆ3[Ô½ƒŽaçùÒËl
3ö–S›¸CäêŠÅøÌêЩV›“ç¤É~҅>‚ŽLË㿕xd҉
+éŒuNûÖÉ¢ÑôFÖÿÛ·MŽ<e¬FðôoóˆäãYôŽ1ŠÏÀ•„’‰Kïùm÷d©ö¾]bí[n³ÞkþmúŠ *gÞ@‰Ñԉí—*Og{jdÈÅh¢–Vêp„ezëtI§F­-õEçÅf´Bf?g{³Ä¢]Mxb‹²]èfú·ŒN'ñê-
T›š,)®mÄdzóHˆeVÉ¿HÀ²_ń9pe…S:h{K¥w”ñËw#”hè¼?#¥U‘žìDdöma”ôÅì¢f|…Nàªåˆ}&	%Ë°•€MªþŽ ©ñ†Líÿ¦‹K–
ÝÈ-‘žžÜ2\$ô<eôݳ¸²™&³Ž= hé…–=}WÇüæ~§›¨ß(«æ]ãªà·H4˜«ËG^bˆîw\É¡Þ¸_XL ­iâ¸0Kªðˆ‘üª³d„ªT†ë¢Ëµ'÷ϨyÓt0Õy-×îˆ@Í6æI€Í¯>¶u:À…¾Q,﹂ÍØYD£M1\â&	ç=M0B ¹ŒGŒü*ӟhäê^xǧQí!Ý9¬SAÁù>¡v³Hlz0«^µ˜¤ooâkµ44íkçnlüýº£›¡™øÍ0…•å˜G}¦¸-µ8ªÏæ´?•ˆ~ñ(Û†<0£%Zqþù­~¯^t>äPa 8$  = Pû֍ӍûÖýŒû֍û֍ûÛkö;à¢Á£ØšP_r¦@ڟ8Ÿ¦“Ÿîhöê¬ÂďT¿çRՊ<R¯Fp·S±ýWGQ*j÷ÇÁ»Y=}ÅÛSt\+~ïÁޅNR"¹RžABÚ«èߤEak٘YO
+vrœ5·7ρ¥zjÎgʏ#Ó,WÁ˜”+mõ{ùÃÒ½–B}Õ+%-›‚O·ÛQé >¯/‘œî1s®R
Xïî¾d‰‚ï€Ï.Ë7˜V2kO‹ŸµCŸÎ”
+FCüx=M=}~%þ»#~ޟä
³o8Ú9V£= ñk<£SîM7„þgÄœfwîÂE_©º»»ã2ÿ¯‰=}ùöBàéfaî÷+‘Ân¸Í•BlÎ7ÅÄa,«†‘ÕkPÂg2aòŒ:I£$y¶î´cŠ±\¥‹4xÓc±§µpÝÀ¬]5BþÊ2w­€Y•Ì-T0“örØ63“Ô)ˆô

h]z6“Ç!-7-Ùæ(g‘ƒš¬mø9ˆêӜSdìq»©žKÄ>znä¦ã6Ö¬ªÕCÀé¾7Ó<9”ð)É·î,s–
£ÏKQ5ŽìºáÕc¾¨œâhÿ;§˜?<&Áßù¿o#XÏ9è¤Ø@"¦¤€—H­?ãˆ5nq‘$§gÁ”SºDõ8&Gç҈r\;ODÐaA±™©i”onAŠJBº‰ŒìkGšiFw…1¸í®Î</±J»ï¸ì"VLKðǂ®$´Ðb9s·s„¡ÀJn}ÉÆøܦ÷]Õ4~ÌÈe#:#ºèÜþì(ç6¶®‰ƒãӖv&•Pža7åŸÚQí
*X[€ïÞޞ¢!Ð-   €†û֍´•ÖûVŠû֍û<rû֑GÃO¶ÿíÙѝˆ)ã¨/ñ}ö/Ãüžlqïð£#˜E8è)¡x\:äY£‘i;ì#Aˆ>8êö^ãX[¬÷ãÉzQ¢§…C؂V²¨‹ÃP¿Zº–ñˆâõæPxg®ÃLž<’’Q[T¡ÕcGÒQ–BnÒ³PZ\¹CÆ°³X¥µJs‰Z]­u³Æ³·Q½¡fSPÝ]3×åÓørS«-ÓÑT'™
|j'ïã[™>ýúÞÙ ÒÅ+qˆz¨…BVèL†ë¹EØîzªqršOC}œYoÍÀ˜öjÆöÌDüŸ5¥’Ë™—™-·ÍÅݓM5XŽØ¾åOVŽfVoøäÓÒmlÿì†Mäþùjê6XZŠ;ûª××½—Ê[(™Ø³?â}Øm1’Éaè»ØýÕ0Ã]œÚØ·û1\Š_êµ7• Y£˜\乧Ù×(5ó®rø‘´ƒ9çx›¼ÚG0œ²ïwnѐç‰ä†¿
ÿÓÄ5¿˜ìYV[¼g}"×ÿ}äEN*Oƒñ5Æ®ÜêâËx„}cSZ=MWhòØéÄ×V¢ó—Pøž7çåxS^«š_= Ñ
+!ó?:¨¯QTânµÇ¼,ñäŸá3O9AœåÕÏ9_-⩏é;®î—ÜΝïÝâ/äƞäX3EA¿Qb´ãwv½¦gW~?îãˆaÏ ?8Žé[ï¿hÎe²O®Ïí€ÿÔO1‡¾ÕX+E¸‰Aaý\iZlEùVw*o3I>ì±´©T谄BãíÙÒLS³…œYyè±Öp¾¿öüzÊà‡›%wJ’æe±)µ8ÅäÖÍê¸%HC4ÊPYb¥%'u™¼ÀjùiUeŠhvçNo½!TðÊôækmŽÖŠÂu«áՑ´õfž¬.FúZtïò¥µNkw	Qík/ѽ¸e	Ó¤!#ó-8–밝µ¦˜ßQÆà8ÁÔQ7満Áâ²eÆ4Ù¸Bú†¦@ú¬ËÇí‰ìQG±%ÁM6”ÒéHKæ
+{qÛøºÞ¾ö<1ÓA^ù¦ÿ÷Œ™~…«úG[Ê&ûeë>
b'֛X‚¯C‰Ÿ=}™—û©ã­n¼=M¬X7f¸ÛÓþ5(wüïÙñ×ì-ɯ(§™Ðú࣓Ë\‘)„9O¦´šQ³W»f€ˆ#99=MëäKž¼ÎCrü¿‡s"X8à•Ñ= Ìó"yL¨Ôžá$$³ÓJ¤õ±A˜)ƒH„ãp¸3nٗX¿ndÐËL"ždˆ’4iîq\X8íÆ¢ˆÖœ®
x’<‚Þ_®S‘|<¯á¤$æXG“H1­dLŸDqYM¹Û~é¬[½bkm*㐞ñdŸ±Ý¯·ýpðoF1W«¸Zµ!ƒò¸´æ§Ã	ÎjçoV#ÛE¹Df‡Òa6î£Ò™†µí­Yh¶°Gµëóå™Ì¨éƒîÜ.,KàìÞ Õç*‰ÌMÄlŨQ«™BJÆc)!ój‘-LE†9;'´3}®±*^÷u€Ê~iJ„ÓËX˺=M«ŠØ=}£ÿëzoʃ= = =}í×
+¹\Ä¡‡n-Ô¼äÅË1cÓF"/USÚÁ9-½6.+{ùpþê)µV,ÖÔSÃÀ½Dù.üö•2³õé8éNv•ÓIÝ;ù}¢Ê:¢Ž5¢>¦á!@,%!ÀمûÖÍ·ûÖÍùÖ=M†û֍û#O%¿I臢X$(‘‚Æ0\7BQp8ÏùߟIlrÐ(í5
‹1¼ãdyÕ= ´ÀÂÜ©4ƒ2Q†œ6ƒœ¼X&åùc<ñ´1L?ái1)òÓDÖv¢­r²¬I´Ä…ËD=}jrìÈ´~IôÕÅ	Ž²ëQ‰F¹è= ¯,B7…Ø‹GëqÒ\ÚM«¼·<QóŸN§’È\“7ée¾÷©*~Îà°ØB£ªøÊè“5E¼
+´¸’d))3…†J“e¹ÏîJ¼¾Èâ®GJ-vöButÞɲ¿ÊæUŠéʓÖ|½¾
+9ˆÀùÍ¡ô…-´}T‘¾Ìiõ“mÖ¦‹XÀåBA|’ÕÙÓu»!•=}ŒöÁ	¬.]–ÚL<ÇëåçÚ¸¥
+QÞo/IA6
+3Õ}?™M#¾Ô9¢!¼-1¾Š¨‹cfæ:”Ù1ÅòæœÎP†éƒ*ìm?‰¢	#3L£m)SÅuø¬}%†=MQƒÚ¡Y&ŸºÓ¶Y]ž6äNÒàuà2Ç\kâ–yòÀåú_̰ڍeÛßUÿ7{Skè¦b;ùâø¶[ú¡MR–$-ûQyò¾µô<קÍ#kGY°æ!§DgTVXÂƤu§3é÷¼¸¦So6Y³Bâł7Š/ÙÀêíΌšê€Â;ëVØÑã½}˜ý’‡fÀ'£>¬·äÂæ³ËÇ]yeïŒO
+ޛñ¶íþ<ÔaŽ¢/uœØ±"E{axÿ·òø·¬8_B÷±Èo×_«PT  !Ìu,äÃM°Ó÷#[P¨ð
@,¢±‹.fŠP¶AÄ.¦P{F´w­Á„~)Ê8Õ£ˆè¦“ÑI¼
Ë
l*¨€ü$Cùý:é÷;±¤§dь™4¦JñLªF
+~T"qQ<z;c¿vLó®…îóxöF摛‹<¦æÔ­«ۘ’Ó3˜Ý_¡¹Ö©äïldo@)áD^¾nbàK9ýބ‚…r¸þ²â«»I„¦Ç’•mJ•ú‰È·æù·‰LmoßÝ	”ù„ÿì,$SY¹©¥l:ÒØßLÒtҙù»íÔGùdGÀÙK§ï¶Ù\»¾ë;¡\Äʐ۸g‹= ^g¶ƒÇqàð_%XßJl†A<LDüÉ(¥ehi5SÂÕ8Ûå˜å¶pßÕ¤M†ÅÈlK¡R¤Ë븙Ù,°’þÏI‡·~%çuP“%³jJ	_{éQßJävt±ÀuíÊqõ8œÈÆÏÐ&¯óUüƶYÏÅdÓ®Àq•XŸÈãÍȾèSôUPÜ¡×ú­ä­„çfœêºX™Á©æ†ì÷UòÐ¥c³{xKðêêúvÖÿˆš”;Òûû¨ÓŽÇŸŽ[²r=}õñ¡³.ò[©[ü©¬çO¦ã!Þ*f¡¿½íÕ…ïÖ›ù֋Ö=M›‡û֍ûÖZ^IÔjàXJœãÙ;/ßsµ½¹gäÙ	Onñ„)æ¿°¤Ì$úá2´—kЙÕDšE96hLw²
+‘rü_Le«¤42rì°BÙThSýdºìL‰æèÀ,;典Gc—»,5ë„éÙMkÆÑL™yÒt¯±ƒÀ<óDø	Oç.Yìvèsœw¾%"™~ê3S~¡%g5p´vÀWh¡Ç]*ô«I±Bc6ªˆ6IҚÊ2¹Ç´0wt‚cÄ2cj˜rfÅR=}´1Ër†|5¦OÉðÊÉbÂ*­ßËòÝkµ_^ËBÅêÎ6u>LucÖ:éFŠ·Ëæù)
+(¯ÉóMËî¹P•Ü'ô1ýÈ¡+-æZˆÀ~Åá,1mψÒgg³Ò4mö‚ãžM
+ߋ=MÏåÃÎ?l»_>‹sŠÅmˆÉVÖS•ðÛÀ£Ò¦.*©ZÈÁ«á>}<Þ
+2	Ëk…§NÎöƒC]~x	
xÊgëlÖ|ôgis¿ªD… =M^#F©;@?€àï]&hÍU¿‡¦8ú9Bv…h¨1ïÏ9Q}ÿ¨Ø,Cäç:ÓÈQßè9³<Ž¬€ø¸/{mØî¤=MFL‰VæRsFþ“sÆ7»Ò¦ í7$¼ö4Ry þÿbB/(	±4B6Bå 0Ïm†欓ΆXUºr“~þUÇðì¼3ådíЀe+‚ÔLX³Ša߶œXŒé„ykœâMÙQ‚é¸=MvdœÐ»·5[û͍ÕU‰¯ÍÑÐÕkµUwdø™ý¦EæVlëÓ
ßIÖ™ö¶ßô9·„ëß=Mxð®£ò–ü-Ócø.´žÐ‡Ò×]G[q5“@É#“<<˜v= bgdŽ[BN”ÄÆè±SS½¨Øäv}GÜS¼øTþ¹3î<q–Æ@î¹wŸØP†ß+N²N|(•
ǁ7ü×ÙÃK+œ|É”åžÍ;ØÑÿù­9­Ž”N•GÞ[^v¸uØÃVï#é>œRc᯾©äeot”\QíäƒÜ7éG݈r‚œÂ7{áA¬„Ýi¯†ìO^¼ü=M£—?ª£œxY£v’_Òáç7ýN&÷‘µ?yΞ<ŠC”Å_û¿3„ï¾ZŸ26'~ ­¶!hv$P{T°À;¡ü0$‡‘@~Ӣ؛U¨9¦a„&Á^U¸ó7¢¹Ê3l‰fPî3b0_=}â%0ärb8SF´öƒÁ„K¥2:?ª(/¥ÁK7¦š”8ÊߥÃÞO<=}ɐ$

X4aðÎ(òßgð0<á?ã1Lþ1éñO±Ü*¨äÔ_²ÄMq¬œ¨‚£4ï›Âü8móûˆöšeÉSºÈ•Qlš=}ã8¢ú‚¸ÒF¶÷O‚鐩…skLÆËy<¼ȉ¬
+ª˜ò?ç“üA¾¤˜®Mk@=M"·=M2ÈÈm²džž°¨ÎmBˊ2©}´äý›i†½¤}u2G7Fó—G9Kë„îuF¢4"ŽÇúB¥u5IT¨Æ˜KµɌHo…˜~:‘WóðSkay:ûÅS
†Z-│jóÑ2é= f&/¥9¼Lí€ÓhFÂWR9Gì„ÔD³Ùyô|ïÂx°eŽi6¹“Óiß¾m¦@»²Œ*p‘]§Fa.EYI²ë;ÙL7ÒËT·kB™Üܱ§ÒP/ò\d‰Ø±ïxӜö·“~!ÒW+SKÀÄÌ QÂ¥Úuè‹bŒë+I1M‚ú=MBîz4Ávqdò‚Ûsìië‚ÔJ«é}pâ¼ÛEü×JáÍʤÁ¥Å<Ùwª¡•I•õŌ{|¦úRJêøz{¦²’:>´“àÎ<ڒf·vq%A5ì‹È= š™EÕ¯KYx©‡ƒEÓvvAÔª6ÇJÎVw1Ûʺ-ïËєɆr‹U҂UÞÈ
Ñ{-EU¼{{kâËz˜ôÿqëÚ•XÝɃÑw=}6}•¨ŒÌç}]S
+Qɇæ&,_TPóÏ!³Þ&dÖV‚ɱå!­X,TBÖÝ)OmŒ/ŠB‚È©C[»iöìµ°†Jfº™ÒË¥Ž6äãzv”ÔRoÊ5ç¨vVúfôÞVnëÔq<õæÿû	]ð®¬|[3ƒûQÓ£u§[(tˆœ'™Ÿ—’ˆG}j½hG–R
ßN¤çÛxÍúep’7g疳—Ò»
+ý”Å–CYÞ§‘‡šPñyf/^3›ù—ηt=M~΅r[Ù¯W78ñ=McAǯióQÝôž|ùRƒ ÐK#<V:@Հ «Ó&IÚVèM³aŠª&™\‡¨¶-jPd‡é0d¦	ÞQì›Ó?}Vì{ñ1ú­ü‚¤æª1O8ÅîHwÍféÌ:åšoÛê÷¿
˜ –K! H8ûn~¬Í=MVû{û֍û֍û΍ûÖ=MY<1b•1ÕÚ«¸R}äÑ=MBD7e4H»mìúü‚ö0IÆâlQc—ªù™iìÓo‚Ü.)µj8rkâÖ~2ﲀùMÁ5)}Þhx´’B¿´OÕÅdhÉTgj¿$IkÏjYu꛷,—!9ôµñÒϬѓ…Œl´‘º¬/ÿ„ø\’’7´sþ¼l½G‡ƒ²¼÷\N¯g¡Ë°¢5´	ÏÀñœ%]²5¬ÙÁ€/%»$E›*IY{é½j~íw]y©Æ2ëoE~Ϫx|e&J’-pq€¡ªst4ÙÉÂo5E܊jäõ4‹ÀÆè U%ŠÅÈé‘sm¦¿Šb~-îØ&}#-Ÿ‹˜_㣄-7ŽˆøcãFaëÜbzfö÷òÉ߶zÕä³Õ¤Žˆ±ðäÈa=}‹
+	8õogәZ*G	~÷»®CŽ]+*	rwoÑޚ̓\hðÓʾ¡´‘9PWÕÖ¡åÝ-T¿ßý&¾~VÐÓ¡¶.C
ÜfŽõTRËDZjS­è–:i؈ÄýgC¢íä|FtW1=MŽT3ÝÖ¹¾Wѽ©6†Sª<†vvQsÜ«¹[³íýŒæœæì
+÷†&+ÇÓxˆ|ñâ.6oÐÀü€ê)+î766ŠÌ$SzyvöjØ͵åƒÌ(‹Ìì\‚eäꐥ­OQ;júØúâfÉ1VÖM×A<ÐQÞ­‡‚[5b–V5ÑςÇý€[§6ù)Äù	™ëî¿–œ~'=}+YhÉ= õïaÕÙ.FXؓåa«£6.GëXÙsã©Ç§³Šó½¬ùD¼³w½˜mNꆓñݲ«=}}»
š7ª3NÂï}4uÛÉ¿þmòŽæԒSŸÄ»KüD>“Þ»ó‚/·¢>Î

fC/÷'šØÒàã„/çϛøíãV·àҜ"sŠ)Ið‚¦= Ù=M"yï+8ÿ)ÜRšY¶õëÒª~–r‘Ü·àZOÏ®šiœ…ØâgÙ¸/c)?‡º¸Tÿ·°±”ëgÇ¿^"¢¿s%ÍGüûïñ¹žúÃۇý[_Em!Ž…-ð͂ ™§ Sæ%(Í-Ðh ¼¯#²%é?)Òˈ°¼m¢Ì;4DØPè@òaڜ-’ý1ˆ¾0K˧p”+ñ‚j¨]»bXo¥BdºZ¬^¸ÚÅâL‹1	ÐP¹¶¦‰ßGì
+{(dH¿_bz1ö¨z¤{BîdHJb´~9ÂlL=}…‰ëH{§gùÓTêÑ]qîþª’g´k8åXySæ¡Q–o­Ñš“¬9ǂ,š1ë X Ð1àpÔӍÛÖîӍû֍û֍û֍ûéW­sI†ðƒtDŽÈ–_];9Òko;š*œó\«¡U>#=Mê;Ð×Uœ´¡™K,tZ†@3#;29Éyàh"¬LʅdtCýV;iñ輗fL‰mŒÑ¸¨6WÑÏ©)&¹øYÿ¤—Ï©×l‚xVS?܆ÊwPÓË͹üÃí”}üqS¥?»	¼ð⡜6rçLtȁrw+7GyhÛᢚöb×w6¶ÅВi·ŒÅ= Kr?K•‡z	Öíê¸ëvžÐÒZ½­v;›ªûøÿäæþ¡V–ìÓў׭åWŒlŠÃ†[m}–j¶Ñƒ‰‰GùP[6ùùÔÿîÀ[–êÔ³SÛ£[~'“ë[Èõæa¶±.nL•ð°#'Ÿ[²óiÖ ³m5½´ŽáHG=}·[ñ=}‘R¡³ÔŸ½¬éBuðåÀjNÞՓñœÔ«Kë}ä¯ØxàeâßN
+’ÓEF…EWUúÙyRêí…Ž¼§ýÔ݆åW“˜è@uðÊ­§)C\Œz
!/O˜ð°^»·\>OeêšQÕïÁbOÙši—óëO~¾…‘æƒ})?ûˆRàg„®¯t[œ|Ýƒ›?-òI€“kSÁ¾?Å·¿sìø§ÓžÞóS‰ ¬%#L®%v/ÐÇs ™| cK#¨g#ŒŸ0àGàÌ<a²¢ÔN7Œë@öÁa&O(’—0@=}_%ù±NäO“¨°6Âc0kš¥ØRUd¢­A¬‡b´˜>‰P¥¹4.ÓВ¸U=MâŒ:9†ë²P;§y™Kìüρ愬ðí6ÁnÑ(T¬°Ëo¤¯óB<þ8ò¹(Õ¿gH¸Xê£Üq†§ÂtÊ4EiûH;¦gÉÙHê¿]q"¿Â¼j;ÃÖIæSYfûZQþ—«ñ†‚¬Ç˃ô\6£8¾ÿQƅ«ý5ÇrÉXK»äõOn¹‘揮“	Œ¼lO´j,âÚ@üÌ Úöp€HäcŽðR”œ+]s(MDð[FðÅÊ= «"Uf*H«%ì›%r~7˜a€wŠ±ñš±:¢h¡:B¯Zªì?MrÉhºB[¨TD²\Íär£¤Hj|ÉAñijäñ2}·jœûGñ¦ä«¯2Uóè<õëX$¹õ…þ”°qgél{L„¯¬ºlR‹sJ\KÄ°[ÆpÒªbÇÖ*ó§IŒ»Ï§â³«*~I²ÊDé¿a5}™µïíu¾,pY_s…ëFµÉÇuZ\qIwEg–­çn­µåUzUðPôØSqƒJ­è­'×U&žñè·ÎH{,eIJ4?£ eu0eñŒûÖ}kŸ‡îl֍û֍û֍ûÖ­ëëõTŠÔ÷ØU|Ãú"­Ó[Tê~ôxrC™,½n9”î·ðé=M”Ì“Ø×nIZî:½
g”þñ™eGc‚£Ù-:‚ð×ÊáÖ&k¦:Ì¿‹Ð•]‹Ð
ÉáÒß&ór»,LŒòlSñº„Š•¬éñEF¸ÈKFIþ¸¼©‰Q@Ãeñ²6WŒ«^­LRÒø\ñb‰‘ e=M;6þ‘N‡ÑñêøŒŒòUÕ	õçú„»bˍ>ÒY‘óFég;_¾ãèÌ.êXܼy§h?§ú³=}Ú̒8žð
+-§™=}6摹·ù…ŠI·
®k·fN՛ÚdFØÄ}–ÏëÞKNC~ۘQ\2ÇX~ôÃ×±ßÎçÅî>}g™Ä|ъÛ'\n^(Ÿ›|lY|öDŽu¿Ù͝‚,‰Xã‡Z¿Dg
+üyñ™ü |y"Š·*8‹'Œ0ß{= ôÑ!96'4ù9pœ Tà=}€E/É°WÄDAùthü¶AO¥<¹2R“uhë#݋A_~§Œ¯Nˆ¿v°ÓÐbea:¢=M=d{'+¼¹¢[$í®(~ÿ4ԚO˜2kr]£ˆqiAmRÞ¶•›i¥Á²iÓD—÷kÒ?µTÜE¹~’V¶—šeîÂ*Íҁme–ª1£5³‡HÆÏul[ĸ}Q­çÀX (µ= q”Wû֍„;ÿ†Öû֍û֍ûŽª®q%´t"+ÄÊLv0øûj€˜Ÿ¡Ús$Î4XÜwÀE¡Ìï%n6ˆ½xD†.±ù…dU0ù
+ª´	NҍÔhá%B+רDXIòÎ赯±zl©á‰EN5´hwuâ´D†×®EÂm±HØbÂù>©î7Dæ^±xc‚}œ¹¹…–4·ùrk†µNSË£ìðARM‡èô|C³ ìÇëR¿ë,MsC±b´Œ*ûjJ$•42º*;[JT8Ê”¦b×U*q/H,ßÌ0Ùâ *¿3ÈXytn4wé{k…¸Æ’Û½jÞaJ}ÇÊ|Á×jáJCµQuVåöؼna­HuT2):ÉzˆÄ	ͱ’¼f¥:ŸV‹\_ƑÆæÊW:£ó1²
+„éÁ´îªZZ¾Á³Ê£îÑaZ=MÇ
+DyÁӎ·nÓZ÷ø¿”¾fWs9üíƒðÈÜáþ&&ù<£A½-/UH^ã€J£S›,2½WÈP²ŸVø2ãžJ³™mÒµWIÿàÄÁÂ—R§¸$ól5FâN³Š‡l*üSiá}4«ÃéLÆАjyʍlÕ¸ÿæ‰_«GxLˆq‹Óå³C6]Ïy䙁Q	Çeª˜V³óûäMˆóÇÂífV|»U½‚,ÕqÆùL{ŽŽ§mÁsV͏ûLœƒ“
ÏíϤ.9R[´KðÔª£ÿôÁ£ð͋.“ˆ_ýá{
ð˜Çc¹s.	Ž[œ›=M¯ã¼$Nf·Ü¥|~t”yðèÅ©ÏÃë²aNõFÛüò™«k´ÃNCÏÚäŸR{„FÆgt>W“™tH=MQǶçwùÆk¯I]]Ž­hWëc|Qš·çîs>¯Ž™ä˜=M±×g¹˜^•ò(œô’±{÷ÇÉsÃÕoþ^	f½“ƒµïÚ}^oôÜ3µïé¿^#$4k3_—àðò!YŠ%<°"ºU/˜ôMÀР×s#zM-˜ØEÀé± Ý·#Ò^.8Iv´°"ibš‡.YtHDšå°ª-bÚ:Akû¤¼=}™th²yA™v¦´ÿ1r˜h$£  )5eñŒûÖ=MZ‹ûVÞ±]xû֍û֍û\~5ù°ùÕéŸN³ßc¢‡~3|dÐ)áèb¢”eaAC˜?áúf¢=}%ù&(n®3”ºKmFÛk0n*ŽÝAˆÀñ7DÍþ³üÍD±{’ÌÄĄ-餿EoÄDÊ¥„jWé}cEGkºL´ì}OÙØwö9iÁ{5
eÓ75þw¬vQCׂŽéìvwl«ªq)e¯†ª&}4Š°B÷$å«4çwKFtD®KØÊؔφø󺏊|S@«FgAí¶:KU·ž÷D
+ŠŽÔòýc“œÈÆò„í¢%ºö‰:ö\ÁºF™¿ó¦›þT„ì7¦a%,‹ê:NöR\Ë
³´Ag“cÑN¦’#-5æ9êîV4yèÚõ
Aã-‡ŽÓLŸøò%ëïzžê’k–ëâ¶_Jxþ³¶-ßy2‰ëËMLóÚxj,Ô;‹©ÓL7¶…’»MÇ{Š¿ÑÌ߁é ÃS®ûÿ”´ôQgçÕÜ®¼Å<-ÊYZçõß=}?V´‹h:¸Váц®ƒï*çM®S'R›æ‘¦ƒ¾uo›Fß	Ñß]E“›þMÙpéSc™òߛh‡˜SïÀn¾r\÷fššlœßðӚ­Ç.ï©ã¾ÿî›îÿ:áࡇ"…þ(ìXî¡fÙ"›ª&ÞÉ8ˆH"˟)\½(´Ž<ˆõNPχ°àk3"ù†'ÊN+ÓQð‚oÀûà k¡A—d&]<	|Ä»±Ú¿d±ÂÙB?7­üsAÒÅv„¬Ë&±ÓÍBãÚfÊ,¨\TZRŠÄ¢èÅu±ö{C>¨¬Y5RL.p= $!0í֍ûοû–í֍û֍ûÖ=MÚ§p—/§34«Iø¶x°Y½€†.a⢖…$gÊ)²W4èö¢£}%±ÝÀú@áØQ¢ó$Ÿ6(ÒÌ6ôûJÕPĀ…áÉÛ¢{ï%o_*~6Ü.G™6c’G±Œ:é%D#kjºv¶ÍK)ÿ|’Ù£„¶,Ò^²äãD·æk¦î´y<œ÷h³D_@ùžrrÒ=}iû‡²wE½žj¾¦vT®ÊX=}oq@¥‚~fe¨üªFe4»ëHâusôÎϸýb‘ÏÃBÉrôÃ8Utѓ¼”e䥪¬Ë4ÅWK:=Mq”^ʐ4ÎK&\(Åâžr”͈0vsRºF}œmØ4º'9T{“Š¦5òôJÅity“Ûֆf3m­ÖºPýT»ÌƑŸmè1º3T¥‡ŠNLôÔ|ř×iƒ–‹ž<.lψzýõ|œÊInÓ»F”(cÓ(¦ÍQ,12:
+ÆTì눘´ó°Ê°Á‘iã䪦cU-::ÕR44ÄÁ›Oãa¦éÃ,“G9¶ìRL}„xÔêP‹³Nc¿c¦–Ç,µO9ÒþRdœ„ØòÐÃÁocåp¶ˆ±L‡ƒzfDÔ4o‰¸áR_§Åœ!ë;LÃëyòwÓ͋Éöô’Û­Åm7ë+…	ðû˜°Å
Hë	©¶¢SM+7xâÍ(VM×y+–gM{ïx}ִލ9èÒÅ'kæ?¶šA<#â[¶f“<­˜´äSÕCz†g²|®%=}y«[Òµ“„É
+hsç±ÐÑC‚Kç.®{ý=}›Íƒ–§9È\ú±”²,çÆ.Û챟͆çª}®æ'=}±oXÖ¼“TÚ
+ûQ±CkçÑ®ÿ<¯XZ§ܯ	6óRÞÇeRïÅT¾²¹]˓š‚5Ȃ¾+Å]¹J™õ¼ÏiúôóÆՇ…ç÷ý³îšºl8YPâš¼GtoÞù¾Z+]ý·›¦ÎìøyÖóӑ߇qïîó!,Ÿ&è!€+@&ãù֍û„ûÖ=MŽ{֍û֍û֍‡›‘Cછ!†])Pu Ž?"ô6@ÿ¿ ‘bXþ§•<­¸6óñRÞC“rçt®M9<ýÒYR‘\H¸tìa9ç몮‘õ=}ù
+ZîU’Ô‰
ûöQÞÓC‘oç Ïñÿў¨ÿgYv¬—D¹
+¸XëŸÞÃrçåu®|;<³×š}®ò'<Ó®Z~½’Ù—õ‘¶C#gñÇ®àKçÚ®<±ŸY—T*E/Oì­B¨I¼¯G\nLœjAkK¤éLdèAdìK¤KD$OFœOEÜLO|ÏB<ÌIÌÈG¬ŽL”ˆA´‰KD=MDœF<	Ml2Áá Ap
éhXÁ„Aî,
ô<áM4òN3NÌ2šÏ71Ö0Ê8'%[FdYMì^OÄÚBÌÚA„ÞK̙¾))Qÿ+c^+¿Þ+-(§£I‰bKcãK¯BK%‚H3“"E{rerJ§óJSI…ÓIã’I'Iÿ+I9ªIkIãëI;JI÷ÊI_‹I
+KÙ:KµºKí{K]ûK£[KÚKóšKÓ½R׿ÿ'P^j9TîçmóœþL¿_o©×hÙtÙÞrùÔv9Ùq‰ÜuéÚsÛgYž= 9Ÿdɑb©•fٜ~9›yI•}•kyoÉh)lyrÉva¹eéãv:wþ§P§QBfPÆdV2fWåR²äS†GT‚GUæÄP¢ÅQÚÇW>„RJ„SVTU|!†CoQƒœi‰9C%ƒ„…¾8é‹9:‹;8;;yº;=M{9«ûÜ.fÄNf
Í·QÕÏÑw¬g¬p£¬tc­ÂC¬íάÁ3­‰s¬Eó­-Ó¬½“­+¬c«|†<x‰~ÙÍWvŒ×:×8—;M9/:ù®8Q®;?o:î8Kï;#N9ÕÎ:‰8ÿ9g:>×çf¢‡æ½7æ¼÷fݗfì¯æ	ï^»±Ç×%Q= n!‚= Q0̍ûÖýnûÖ=M†‹û֍û֍ûÞëçSÒSl_ a­Gá­qÁ¬,­Ó
­Ö±¬pq­ñ­¼Ñ¬³‘¬Ú­·)­i¬鬁I­‰¬Ñ	¬(9†CdVß.“NÃe~šžÃ˜AƒƒC~Qƒp)™IÔyƒ…™C„EÑ5ƒwUC’mÃyƒ{}Ç¡qűQÇ©‡‹†Ä‰ÔÌ‹‹ÜÄ	„T=M‚ì†|$„›­†<ˆ\</ÛC¬Rìöƒ¬Á¬%3¬=}³¼“ªÿ¹†œº$¹d¼‹ä¹DyˆÄzŒÄ{
+^¶›{	w;I÷:©ö;QWZ†ÿ6V.ôNƒë>ïÛï9/XAÃô1CQïâ¼T–¿VF½Uz½W}”‡·­[wüãUÃû-ÃMÞŸý•Ç­*/îƒ3—ìHâòxúˆöÝWŸO¿¬ø¬c½Û1	ÇÑ·q¯Ï÷„*Bn&5­£«?Aä¸pBq8ÑAÌH4~¼©@Šf2/B«vqåۈ“,YÆ6{œªCZæ3Ï«Æ)åÍd‚2‘XÉè±|LmAÂÅ2jM~Ç1õò©ý	e²¬‚hF\ÓH¹uLëF¢0-’ª=MÙdÄ\™~ÑK¿¨pà+ªÕ¥äž1QÉÈ÷JF²¶0MkªõÅäûòBƒyñÞ¼xu~\Ë@2w2ÕK«)uäñʇU±Î¦Èws¬ÎE–ö6o˜ÝšB—ñС8úðÿW’æîûäWWíeÉ6îørEÆÖ6‹ú¨£åõ–îñþ•0ÁZ©8½]w7±ÁËèùm4Nª0…šª*ÝdÅþ’?ýu_qÎßS-0¥mµèRpÄ:D/|cd°ÁÃ×'ãäÙ
„¤›=}Iæ¯2]gÛ»QÂøx±†¼(_þS›[WaÌ»Hæl2ÍF4±Ê=MüTŸ_}¹
™†ÚÃy³×cÓåäYÿ|½Gޙ[P¬|¹7ªx«ä=}+6Û§EBår—éROŸvÙ׉KJ1šÕøÍç:Í؍Z%2/PÖ½! &‹û֍×ï֍û֍û֍ûÖÑÖQÕ1–³éf®ßT	‡×i3îY€Ž»Til»÷FmÁòDS…¡ÿOTwfNÒO«­cEöØôÅêR›ÝüøÄy|:ÍÔ:éœÛúÙp­ó—Í6v³Ü°¬Ú#´÷F§ð‚ÃÙ
+³†ÿ½œÞðJÏBýV§ìûÕ΄ù
_¹–
+ÜiÛk;ì‡:™ÜÕ瘊ÏÑٍ¿‘(ÁÜÎ0¹/s™}ÿ\¸{TîYm–½B~XÂF¼‚gýW~_ƙE¬bçý¾^
~’ª•ðÃhÀøIƒ‰=MPû™e7ýºCܟöޒª¯ï9«sœÈ³ä1þôjW‡'o‹ÆËÓ¬ûO‰ã9g0|ÆùåZ
+ÒlE¤ïΊìùà=}º
+¼@¯‹Ë«Q¼3\ÃÑNé(®¤öÚP#øãýa¿ÌDºÕ÷u9ëq/‘VԀ>·™ZôÝÂ]«ÙêsbK†“ºâ=MAU9îv˜Iâ‰á„±è‹±Qí8ï.B˜Zê}Ç:xä)Ž¨ö¢³­zƒAg¨9—´ÁMƒyçYŽ¨î®rԀH«Y= Hä™G„Ä,í9ä<֓¡D>«×„ÁLm	ã„v“° ŽlfÜcšªp³Ö,„JKùë%ÂÙCñ™·TÃ\-è@FѸí<2±üÌAŸ¨7™¿èiQÊð°$syäZ–‘¬«¤²àÚ'™¦÷°Ïéd>ªq¾ºTÂU}ëpæQ­™Lƒ=}ûøëq@BiÆ4›à\êóÜèÜëgœáׄ@KÙèo1jr¶jtÃV‰l“zó¾î”ÇW8äpfP¦l‚JS¸í|6иÅ̀5‹yïfVÓ­=}‚/øïa.“´ƒ¼Dǟóñ¿"·Øì5Β­$0h0á߉ãž“‹?Ý¿»¿äDG‘_©­¤ÿh­Ä_h;I±vŽ–nŽ
~ž>á;ò­=M™óýŽ
å¯7‘¯ɕý#”{}  ·Z봔ÎƄNÏRǽûV«A¹³ì֍ûÖyíû¼9g:&@*†!e*$£vËbáª;Vp•c,ÈåEUV!4yø Ô#Û%î%i[óX¢î¾Ù@à’À†G!þ¨@ÝIÐNZ= Ýóá¤àYá /žVâ ÷6X€ˆH\Øü&ð8˜ûwâ6õ2@ý Êù.ž‡=M+ç-n¢ƒò|øM/<ýŽNÌS‰Y¬‹Ý)z¿¥—CoáÎ㒱	ÐÁï›XÙ£!õ܀d?¯xðì
+ÁiŸ;ª•äÀž‡%Šn= =M+W= ÓÖc[aS
+FÁð]Nô‡Ý'= “qr(¶ù¤nŒü«òÿ¿d&ÿÈõT4Þ=}z|ö ¿OW×SMtdH.τãRX&§o3ؘÜXÍ^œÊM–í£W´iâ]NüOå£S£Å·ƒç÷­˜Ý§½GÑUy¹¦ß§/6P0(Cúýb"þ¥°VٌÄᣈ’ÓÙ@¾YýòDŽŒ{òÃv?’EP©”=MBé­\ĽYäýRò	øfâëEEf¼D+gC×úDZGÅÿ±Ç?TzÙ¡±†Ï€ÁÕ¯¦ð‰vZ’mT}Œ3x˘z×cºrÑM=M„c-ɩԈ™7½wæc§Î»cû¾yf‡ÙWòŒÆÝÔc¥³ôØfƒ«Äñ·9‰ø%­g:y”^+{U]¤þ‚…[&fӁÏY낫‡Gªõ‡¹¦ÖŒð
þ¬m„oÛø‘?/ÛS’.[S›9ÛùœC›…/û2”²Y£ÎÑ%/sy¢×ÌùJ­W6Oí\g0^JùêßÏ0í[Ü“'ÏÔ>žÀ-¿[ÔW?Y]±žØÙÃî<~ÎëR~Ìf¾Z—/×¼_á¾Þê+îoÐñ{Þ\e3K%©¹§íB¹§(c=}ËÈ·SzÔnf§èx}o\9öf|%Ýå¥~©‚Iǀü€ñY8}FfŸú@Rú1éþ3‚÷˂‹ótQøvœû|³Îaá,Óé>BG6Òê}—ÄJ|¶=}°Žˆöf6žõk¶ÌºHgN’j‡Ò{柾M;9·é—§WèO±›Ä3қËÒyt™	;ù´ˆà©aš|—Ó^!ÝøûšÄ
+(VV¸ÇÙcÏ>yoçzÃvòG{3Þ£½šŠcמôŒíŚé;°OÛ‰
GØ<wÜW>	rU]Žq­{û'ùÝír{*øï?t-ígùWÿ…&§]m}×ût¥‚Ë~ß&>&Õv!b#ÅÌ‚q¢µ|jŽÍüùÉ^Æ&™ôžþŸ~sIµ"“]d)uâ´‘ºvk	Å\<͉ÿ­öꍽƒÂ

+ïBçϧmÙIólÜoëVbƒ¦¯éWÇû3` });
+  var imports = {
+    "a": wasmImports
+  };
+  this.setModule = (data3) => {
+    WASMAudioDecoderCommon2.setModule(EmscriptenWASM, data3);
+  };
+  this.getModule = () => WASMAudioDecoderCommon2.getModule(EmscriptenWASM);
+  this.instantiate = () => {
+    this.getModule().then((wasm) => WebAssembly.instantiate(wasm, imports)).then((instance) => {
+      const wasmExports = instance.exports;
+      assignWasmExports(wasmExports);
+      wasmMemory = wasmExports["l"];
+      updateMemoryViews();
+      initRuntime(wasmExports);
+      ready();
+    });
+    this.ready = new Promise((resolve) => {
+      ready = resolve;
+    }).then(() => {
+      this.HEAP = wasmMemory.buffer;
+      this.malloc = _malloc;
+      this.free = _free;
+      this.create_decoder = _create_decoder;
+      this.send_setup = _send_setup;
+      this.init_dsp = _init_dsp;
+      this.decode_packets = _decode_packets;
+      this.destroy_decoder = _destroy_decoder;
+    });
+    return this;
+  };
+}
+
+// ../../node_modules/@wasm-audio-decoders/ogg-vorbis/src/OggVorbisDecoder.js
+function Decoder() {
+  this._init = () => {
+    return new this._WASMAudioDecoderCommon().instantiate(this._EmscriptenWASM, this._module).then((common) => {
+      this._common = common;
+      this._input = this._common.allocateTypedArray(
+        this._inputSize,
+        Uint8Array
+      );
+      this._firstPage = true;
+      this._inputLen = this._common.allocateTypedArray(1, Uint32Array);
+      this._outputBufferPtr = this._common.allocateTypedArray(1, Uint32Array);
+      this._channels = this._common.allocateTypedArray(1, Uint32Array);
+      this._sampleRate = this._common.allocateTypedArray(1, Uint32Array);
+      this._samplesDecoded = this._common.allocateTypedArray(1, Uint32Array);
+      const maxErrors = 128 * 2;
+      this._errors = this._common.allocateTypedArray(maxErrors, Uint32Array);
+      this._errorsLength = this._common.allocateTypedArray(1, Int32Array);
+      this._frameNumber = 0;
+      this._inputBytes = 0;
+      this._outputSamples = 0;
+      this._decoder = this._common.wasm.create_decoder(
+        this._input.ptr,
+        this._inputLen.ptr,
+        this._outputBufferPtr.ptr,
+        this._channels.ptr,
+        this._sampleRate.ptr,
+        this._samplesDecoded.ptr,
+        this._errors.ptr,
+        this._errorsLength.ptr,
+        maxErrors
+      );
+    });
+  };
+  Object.defineProperty(this, "ready", {
+    enumerable: true,
+    get: () => this._ready
+  });
+  this.reset = () => {
+    this.free();
+    return this._init();
+  };
+  this.free = () => {
+    this._common.wasm.destroy_decoder(this._decoder);
+    this._common.free();
+  };
+  this.sendSetupHeader = (data3) => {
+    this._input.buf.set(data3);
+    this._inputLen.buf[0] = data3.length;
+    this._common.wasm.send_setup(this._decoder, this._firstPage);
+    this._firstPage = false;
+  };
+  this.initDsp = () => {
+    this._common.wasm.init_dsp(this._decoder);
+  };
+  this.decodePackets = (packets) => {
+    let outputBuffers = [], outputSamples = 0, errors = [];
+    for (let packetIdx = 0; packetIdx < packets.length; packetIdx++) {
+      const packet = packets[packetIdx];
+      this._input.buf.set(packet);
+      this._inputLen.buf[0] = packet.length;
+      this._common.wasm.decode_packets(this._decoder);
+      const samplesDecoded = this._samplesDecoded.buf[0];
+      const channels2 = [];
+      const outputBufferChannels = new Uint32Array(
+        this._common.wasm.HEAP,
+        this._outputBufferPtr.buf[0],
+        this._channels.buf[0]
+      );
+      for (let channel2 = 0; channel2 < this._channels.buf[0]; channel2++) {
+        const output = new Float32Array(samplesDecoded);
+        if (samplesDecoded) {
+          output.set(
+            new Float32Array(
+              this._common.wasm.HEAP,
+              outputBufferChannels[channel2],
+              samplesDecoded
+            )
+          );
+        }
+        channels2.push(output);
+      }
+      outputBuffers.push(channels2);
+      outputSamples += samplesDecoded;
+      this._frameNumber++;
+      this._inputBytes += packet.length;
+      this._outputSamples += samplesDecoded;
+      for (let i = 0; i < this._errorsLength.buf; i += 2) {
+        const errorDescription = this._common.codeToString(this._errors.buf[i]);
+        const functionName = this._common.codeToString(this._errors.buf[i + 1]);
+        errors.push({
+          message: errorDescription + " vorbis_synthesis" + functionName,
+          frameLength: packet.length,
+          frameNumber: this._frameNumber,
+          inputBytes: this._inputBytes,
+          outputSamples: this._outputSamples
+        });
+      }
+      this._errorsLength.buf[0] = 0;
+    }
+    return this._WASMAudioDecoderCommon.getDecodedAudioMultiChannel(
+      errors,
+      outputBuffers,
+      this._channels.buf[0],
+      outputSamples,
+      this._sampleRate.buf[0],
+      16
+    );
+  };
+  this._isWebWorker = Decoder.isWebWorker;
+  this._WASMAudioDecoderCommon = Decoder.WASMAudioDecoderCommon || WASMAudioDecoderCommon;
+  this._EmscriptenWASM = Decoder.EmscriptenWASM || EmscriptenWASM;
+  this._module = Decoder.module;
+  this._inputSize = 128 * 1024;
+  this._ready = this._init();
+  return this;
+}
+var setDecoderClass = /* @__PURE__ */ Symbol();
+var OggVorbisDecoder = class {
+  constructor() {
+    this._onCodec = (codec2) => {
+      if (codec2 !== "vorbis")
+        throw new Error(
+          "@wasm-audio-decoders/ogg-vorbis does not support this codec " + codec2
+        );
+    };
+    new WASMAudioDecoderCommon();
+    this._init();
+    this._ready = this[setDecoderClass](Decoder);
+  }
+  _init() {
+    this._vorbisSetupInProgress = true;
+    this._totalSamplesDecoded = 0;
+    this._codecParser = new codec_parser_default("audio/ogg", {
+      onCodec: this._onCodec,
+      enableFrameCRC32: false
+    });
+  }
+  async [setDecoderClass](decoderClass) {
+    if (this._decoder) {
+      const oldDecoder = this._decoder;
+      await oldDecoder.ready.then(() => oldDecoder.free());
+    }
+    this._decoder = new decoderClass();
+    return this._decoder.ready;
+  }
+  get ready() {
+    return this._ready;
+  }
+  async reset() {
+    this._init();
+    return this._decoder.reset();
+  }
+  free() {
+    this._decoder.free();
+  }
+  async decodeOggPages(oggPages) {
+    const packets = [];
+    for (let i = 0; i < oggPages.length; i++) {
+      const oggPage2 = oggPages[i];
+      if (this._vorbisSetupInProgress) {
+        if (oggPage2[data2][0] === 1) {
+          this._decoder.sendSetupHeader(oggPage2[data2]);
+        }
+        if (oggPage2[codecFrames2].length) {
+          const headerData = oggPage2[codecFrames2][0][header2];
+          this._decoder.sendSetupHeader(headerData[vorbisSetup2]);
+          this._decoder.initDsp();
+          this._vorbisSetupInProgress = false;
+        }
+      }
+      packets.push(...oggPage2[codecFrames2].map((f) => f[data2]));
+    }
+    const decoded = await this._decoder.decodePackets(packets);
+    this._totalSamplesDecoded += decoded.samplesDecoded;
+    const oggPage = oggPages[oggPages.length - 1];
+    if (oggPage && oggPage[isLastPage2]) {
+      const samplesToTrim = this._totalSamplesDecoded - oggPage[totalSamples2];
+      if (samplesToTrim > 0) {
+        for (let i = 0; i < decoded.channelData.length; i++)
+          decoded.channelData[i] = decoded.channelData[i].subarray(
+            0,
+            decoded.samplesDecoded - samplesToTrim
+          );
+        decoded.samplesDecoded -= samplesToTrim;
+        this._totalSamplesDecoded -= samplesToTrim;
+      }
+    }
+    return decoded;
+  }
+  async decode(vorbisData) {
+    return this.decodeOggPages([...this._codecParser.parseChunk(vorbisData)]);
+  }
+  async flush() {
+    const decoded = await this.decodeOggPages([...this._codecParser.flush()]);
+    await this.reset();
+    return decoded;
+  }
+  async decodeFile(vorbisData) {
+    const decoded = await this.decodeOggPages([
+      ...this._codecParser.parseAll(vorbisData)
+    ]);
+    await this.reset();
+    return decoded;
+  }
+};
+
+// src/decode-vorbis.src.js
+var EMPTY = Object.freeze({ channelData: Object.freeze([]), sampleRate: 0 });
+async function decode(src) {
+  let buf = src instanceof Uint8Array ? src : new Uint8Array(src);
+  let dec = await decoder();
+  try {
+    let a = dec.decode(buf);
+    let b = dec.flush();
+    return hasAudio(b) ? merge(a, b) : a;
+  } finally {
+    dec.free();
+  }
+}
+async function decoder() {
+  let upstream = new OggVorbisDecoder();
+  await upstream.ready;
+  let codec2 = upstream._decoder, wasm = codec2?._common?.wasm;
+  if (typeof codec2?.sendSetupHeader !== "function" || typeof codec2.initDsp !== "function" || typeof codec2.decodePackets !== "function" || typeof wasm?.malloc !== "function" || typeof wasm.free !== "function" || !(wasm.HEAP instanceof ArrayBuffer)) {
+    upstream.free();
+    throw Error("Unsupported @wasm-audio-decoders/ogg-vorbis internals");
+  }
+  let heapEnd = wasm.malloc(1);
+  if (!heapEnd) {
+    upstream.free();
+    throw Error("Could not initialize Ogg Vorbis decoder");
+  }
+  wasm.free(heapEnd);
+  heapEnd = Math.min(wasm.HEAP.byteLength, Math.ceil((heapEnd + 65536) / 65536) * 65536);
+  let initialMemory = new Uint8Array(wasm.HEAP, 0, heapEnd).slice();
+  let createParser = () => new codec_parser_default("audio/ogg", {
+    onCodec: (c) => {
+      if (c !== "vorbis") throw Error("@audio/decode-vorbis does not support this codec " + c);
+    },
+    enableFrameCRC32: false
+  });
+  let parser = createParser(), setup = true, total2 = 0, fresh = true;
+  let resetPending = false, ended = false, freed = false;
+  let resetCodec = () => {
+    if (wasm.HEAP.byteLength < initialMemory.length)
+      throw Error("Could not reset Ogg Vorbis decoder");
+    new Uint8Array(wasm.HEAP, 0, initialMemory.length).set(initialMemory);
+    codec2._firstPage = true;
+    codec2._frameNumber = codec2._inputBytes = codec2._outputSamples = 0;
+  };
+  let startStream = () => {
+    resetCodec();
+    parser = createParser();
+    setup = true;
+    total2 = 0;
+    fresh = true;
+    resetPending = false;
+  };
+  let decodePages = (pages) => {
+    if (!pages.length) return null;
+    let packets = [];
+    for (let page3 of pages) {
+      if (setup) {
+        if (page3[data2][0] === 1) codec2.sendSetupHeader(page3[data2]);
+        if (page3[codecFrames2].length) {
+          let setupHeader = page3[codecFrames2][0][header2][vorbisSetup2];
+          codec2.sendSetupHeader(setupHeader);
+          codec2.initDsp();
+          setup = false;
+        }
+      }
+      packets.push(...page3[codecFrames2].map((f) => f[data2]));
+    }
+    if (!packets.length) return null;
+    let decoded = codec2.decodePackets(packets);
+    total2 += decoded.samplesDecoded;
+    let page2 = pages[pages.length - 1];
+    if (page2?.[isLastPage2]) {
+      let trim = total2 - page2[totalSamples2];
+      if (trim > 0) {
+        let keep = Math.max(0, decoded.samplesDecoded - trim);
+        for (let i = 0; i < decoded.channelData.length; i++)
+          decoded.channelData[i] = decoded.channelData[i].subarray(0, keep);
+        total2 -= decoded.samplesDecoded - keep;
+        decoded.samplesDecoded = keep;
+      }
+    }
+    return decoded;
+  };
+  upstream.decode = (chunk) => {
+    if (freed) throw Error("Decoder already freed");
+    if (ended) throw Error("Decoder already flushed");
+    if (!chunk) return EMPTY;
+    let buf = chunk instanceof Uint8Array ? chunk : new Uint8Array(chunk);
+    if (!buf.length) return EMPTY;
+    if (resetPending) startStream();
+    if (fresh && isCompleteOggStream(buf)) {
+      let r2 = decodePages([...parser.parseAll(buf)]);
+      parser = null;
+      resetPending = true;
+      return hasAudio(r2) ? r2 : EMPTY;
+    }
+    fresh = false;
+    let r = decodePages([...parser.parseChunk(buf)]);
+    return hasAudio(r) ? r : EMPTY;
+  };
+  upstream.flush = () => {
+    if (freed || ended) return EMPTY;
+    ended = true;
+    if (resetPending) {
+      parser = null;
+      return EMPTY;
+    }
+    try {
+      let r = decodePages([...parser.flush()]);
+      return hasAudio(r) ? r : EMPTY;
+    } finally {
+      parser = null;
+    }
+  };
+  let free2 = upstream.free.bind(upstream);
+  upstream.free = () => {
+    if (freed) return;
+    freed = true;
+    parser = null;
+    free2();
+    initialMemory = null;
+  };
+  return upstream;
+}
+function hasAudio(result) {
+  return !!result?.channelData?.[0]?.length;
+}
+function isCompleteOggStream(buf) {
+  let offset = 0, first = true;
+  while (offset < buf.length) {
+    if (offset + 27 > buf.length || buf[offset] !== 79 || buf[offset + 1] !== 103 || buf[offset + 2] !== 103 || buf[offset + 3] !== 83 || buf[offset + 4] !== 0)
+      return false;
+    let flags = buf[offset + 5], segments2 = buf[offset + 26];
+    if (first && !(flags & 2)) return false;
+    let body = offset + 27 + segments2;
+    if (body > buf.length) return false;
+    let end = body;
+    for (let i = offset + 27; i < body; i++) end += buf[i];
+    if (end > buf.length) return false;
+    if (flags & 4) return end === buf.length;
+    offset = end;
+    first = false;
+  }
+  return false;
+}
+function merge(a, b) {
+  if (!hasAudio(b)) return a;
+  if (!hasAudio(a)) return b;
+  return {
+    channelData: a.channelData.map((ch, i) => {
+      let bc = b.channelData[i] || b.channelData[0];
+      let m = new Float32Array(ch.length + bc.length);
+      m.set(ch);
+      m.set(bc, ch.length);
+      return m;
+    }),
+    sampleRate: a.sampleRate
+  };
+}
+export {
+  decoder,
+  decode as default
+};