watr 4.7.0 → 4.7.2

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "watr",
-  "version": "4.7.0",
+  "version": "4.7.2",
   "description": "Light & fast WAT compiler – WebAssembly Text to binary, parse, print, transform",
   "main": "watr.js",
   "bin": {

package/src/compile.js

@@ -37,17 +37,10 @@ const cleanup = (node, result) => {
 }
 
 
-/**
- * Converts a WebAssembly Text Format (WAT) tree to a WebAssembly binary format (WASM).
- *
- * @param {string|Array} nodes - The WAT tree or string to be compiled to WASM binary.
- * @returns {Uint8Array} The compiled WASM binary. When the WAT carries
- *   `@metadata.code.<type>` annotations, the result also exposes a `.metadata`
- *   property — `{ [type]: [[absoluteByteOffset, data], ...] }`, each offset the
- *   instruction's position in the final binary. That's the hook a source-map
- *   emitter needs to correlate generated wasm back to its source.
- */
-export default function compile(nodes) {
+// Internal: assemble the module. sizeOnly=false → wasm bytes (Uint8Array); sizeOnly=true →
+// just the byte LENGTH, skipping materialization of the multi-MB binary — that's size()'s
+// reason to exist (the optimizer's size-revert guard can't afford to build bytes it discards).
+function assemble(nodes, sizeOnly) {
   // normalize to (module ...) form
   if (typeof nodes === 'string') err.src = nodes, nodes = parse(nodes) || []
   else err.src = '' // clear source if AST passed directly
@@ -63,10 +56,10 @@ export default function compile(nodes) {
   else if (typeof nodes[0] === 'string') nodes = [nodes]
 
   // binary abbr "\00" "\0x61" ...
-  if (nodes[idx] === 'binary') return Uint8Array.from(nodes.slice(++idx).flat())
+  if (nodes[idx] === 'binary') { const b = Uint8Array.from(nodes.slice(++idx).flat()); return sizeOnly ? b.length : b }
 
   // quote "a" "b"
-  if (nodes[idx] === 'quote') return compile(nodes.slice(++idx).map(v => v.valueOf().slice(1, -1)).flat().join(''))
+  if (nodes[idx] === 'quote') return assemble(nodes.slice(++idx).map(v => v.valueOf().slice(1, -1)).flat().join(''), sizeOnly)
 
   // expand grouped imports: (import "mod" (item "name" type)*) -> individual imports
   // compact import section (Phase 3)
@@ -241,6 +234,26 @@ export default function compile(nodes) {
   // pre-compute sections that may collect string constants (for strings section ordering)
   const globalSection = bin(SECTION.global)
   const elemSection = bin(SECTION.elem)
+  // measure: byte LENGTH only — skip building + materializing the multi-MB code byte array
+  // (the optimizer's size-revert guard only needs the count). Sizes the code section via
+  // codeItemSize; other sections are small, built normally + summed. Same string-collection
+  // ORDER as the emit path (global, elem, code, meta, data → strings).
+  if (sizeOnly) {
+    const codeSizes = ctx.code.filter(Boolean).map(item => codeItemSize(item, ctx))
+    const innerLen = codeSizes.length ? ulebSize(codeSizes.length) + codeSizes.reduce((a, b) => a + b, 0) : 0
+    const codeSecLen = codeSizes.length ? 1 + ulebSize(innerLen) + innerLen : 0  // SECTION.code + vec(vec(items))
+    const metaSection = binMeta()
+    const dataSection = bin(SECTION.data)
+    const stringsSection = ctx.strings.length ? [SECTION.strings, ...vec([0x00, ...vec(ctx.strings.map(s => vec(s)))])] : []
+    const others = [
+      bin(SECTION.custom), bin(SECTION.type), bin(SECTION.import), bin(SECTION.func),
+      bin(SECTION.table), bin(SECTION.memory), bin(SECTION.tag), stringsSection,
+      globalSection, bin(SECTION.export), bin(SECTION.start, false), elemSection,
+      bin(SECTION.datacount, false), metaSection, dataSection
+    ]
+    return 8 + codeSecLen + others.reduce((s, sec) => s + sec.length, 0)   // 8 = magic + version
+  }
+
   // inline bin(code) so the per-function item bytes survive — with ctx.codeSizePrefix
   // they let us lift code-metadata positions to absolute binary offsets below
   const codeItems = ctx.code.filter(Boolean).map(item => build[SECTION.code](item, ctx)).filter(Boolean)
@@ -317,6 +330,19 @@ export default function compile(nodes) {
   }
 }
 
+/**
+ * Convert a WAT tree (or source string) to a wasm binary (Uint8Array). When the WAT carries
+ * `@metadata.code.<type>` annotations the result also exposes `.metadata` —
+ * `{ [type]: [[absByteOffset, data], ...] }`, the hook a source-map emitter needs.
+ */
+export default function compile(nodes) { return assemble(nodes) }
+
+/**
+ * Byte size of `compile(nodes)` without materializing the binary — a peer transform for
+ * tooling (the optimizer's size-revert guard, size budgeting). Exactly `compile(nodes).length`,
+ * summed from section sizes instead of building them (invariant-tested).
+ */
+export function size(nodes) { return assemble(nodes, true) }
 
 /** Check if node is a valid index reference ($name or number) */
 const isIdx = n => n?.[0] === '$' || !isNaN(n)
@@ -1062,6 +1088,59 @@ const instr = (nodes, ctx) => {
   return out.push(0x0b), out
 }
 
+// LEB128 byte-width of an unsigned integer (exact, reuses uleb so it can never drift).
+const ulebSize = (n) => uleb(n).length
+
+// Size-only twin of instr(): the byte LENGTH of the encoded instruction stream,
+// WITHOUT building the (multi-MB) byte array. Reuses every HANDLER for exact
+// immediate widths + index resolution — only `out.push(...bytes)` accumulation is
+// replaced by integer summation (the dominant cost on large modules). The
+// opcode-value tweaks in instr() (typed-select / nullable-reftype) change a byte
+// VALUE, not the length, so they're irrelevant here. MUST equal instr(...).length
+// (asserted by the byteSize↔compile invariant test).
+const instrSize = (nodes, ctx) => {
+  let size = 0, meta = []
+  while (nodes?.length) {
+    let op = nodes.shift()
+    if (op?.[0] === '@metadata') { meta.push(op.slice(1)); continue }
+    if (Array.isArray(op)) { op.loc != null && (err.loc = op.loc); err(`Unknown instruction ${op[0]}`) }
+    const opc = INSTR[op] || err(`Unknown instruction ${op}`)
+    let n = opc.length
+    if (HANDLER[op]) n += HANDLER[op](nodes, ctx, op).length
+    if (meta.length) { for (const [type, data] of meta) ((ctx.meta[type] ??= []).push([size, data])); meta = [] }
+    size += n
+  }
+  return size + 1   // trailing 0x0b (end)
+}
+
+// Size-only twin of build[SECTION.code]: byte LENGTH of one function's code item.
+// Mirrors the builder exactly (local setup, squash, metadata bookkeeping, vec
+// framing) but uses instrSize for the body — so locals/strings/metadata side
+// effects on ctx stay identical, only the body byte array is never materialized.
+const codeItemSize = (body, ctx) => {
+  let [typeidx, param] = body.shift()
+  if (!param) [, [param]] = ctx.type[id(typeidx, ctx.type)]
+  ctx.local = Object.create(param); ctx.block = []
+  ctx.local.name = 'local'; ctx.block.name = 'block'
+  if (ctx._codeIdx === undefined) ctx._codeIdx = 0
+  let codeIdx = ctx._codeIdx++
+  while (body[0]?.[0] === 'local') {
+    let [, ...types] = body.shift()
+    if (isId(types[0])) { let nm = types.shift(); if (nm in ctx.local) err(`Duplicate local ${nm}`); else ctx.local[nm] = ctx.local.length }
+    ctx.local.push(...types)
+  }
+  ctx.meta = {}
+  const bytesLen = instrSize(body, ctx)
+  let loctypes = ctx.local.slice(param.length).reduce((a, type) => (type == a[a.length - 1]?.[1] ? a[a.length - 1][0]++ : a.push([1, type]), a), [])
+  const locals = vec(loctypes.map(([n, t]) => [...uleb(n), ...reftype(t, ctx)]))
+  const funcIdx = ctx.import.filter(imp => imp[2][0] === 'func').length + codeIdx
+  for (const type in ctx.meta) { for (const inst of ctx.meta[type]) inst[0] += locals.length; ((ctx.metadata ??= {})[type] ??= []).push([funcIdx, ctx.meta[type]]) }
+  ctx.local = ctx.block = ctx.meta = null
+  const bodyLen = locals.length + bytesLen
+  ;(ctx.codeSizePrefix ??= [])[codeIdx] = ulebSize(bodyLen)   // = vec prefix width
+  return ulebSize(bodyLen) + bodyLen                          // vec([...locals, ...bytes]).length
+}
+
 // instantiation time value initializer (consuming) - normalize then encode + add end byte
 const expr = (node, ctx) => instr(normalize([node], ctx), ctx)
 

package/src/optimize.js

@@ -7,7 +7,7 @@
  * @module wat/optimize
  */
 
-import compile from './compile.js'
+import compile, { size } from './compile.js'
 import parse from './parse.js'
 
 // Fixpoint round caps — empirical convergence bounds, not correctness limits.
@@ -68,7 +68,10 @@ const count = (node) => {
  * @returns {number}
  */
 const binarySize = (ast) => {
-  try { return compile(ast).length } catch { return Infinity }
+  // `size` = byte length without materializing the binary — the size-revert guard only needs
+  // the count, and re-encoding the whole module each round is the optimizer's dominant cost on
+  // large modules. Exactly compile(ast).length (invariant-tested).
+  try { return size(ast) } catch { return Infinity }
 }
 
 /**
@@ -1873,7 +1876,7 @@ const buildInline = (params, locals, inlResult, cBody, args) => {
  *
  * A callee qualifies when it is small (≤ INLINE_MAX_NODES IR nodes), named with
  * named params/locals, single-result-or-void, non-recursive, not pinned
- * (export/start/elem/ref.func), not a SIMD_PROTECTED transcendental, and free of
+ * (export/start/elem/ref.func), not in the caller's `pin` set, and free of
  * depth-relative branches / tail calls (the inlParse + inlUnsafe liftability
  * contract). Runs to a fixpoint so small-helper chains (sdf → sdRep) collapse.
  *
@@ -1893,7 +1896,7 @@ const buildInline = (params, locals, inlResult, cBody, args) => {
 const INLINE_MAX_NODES = 90
 const isV128SimdHelper = (params, inlResult) =>
   inlResult === 'v128' && params.length > 0 && params.every(p => p.type === 'v128')
-const inline = (ast, { simdOnly = false } = {}) => {
+const inline = (ast, { simdOnly = false, pin = EMPTY_SET } = {}) => {
   if (!Array.isArray(ast) || ast[0] !== 'module') return ast
 
   const skip = new Set()  // callees with a non-inlinable site (arity mismatch) — don't re-pick
@@ -1917,7 +1920,7 @@ const inline = (ast, { simdOnly = false } = {}) => {
     // Pick a small, liftable, non-recursive callee with ≥1 plain-call site.
     let calleeName = null, parsed = null
     for (const [name, fn] of funcByName) {
-      if (skip.has(name) || pinned.has(name) || otherRef.has(name) || SIMD_PROTECTED.has(name)) continue
+      if (skip.has(name) || pinned.has(name) || otherRef.has(name) || pin.has(name)) continue
       if (!(callRefs.get(name) >= 1)) continue
       if (inlBodySize(fn) > INLINE_MAX_NODES) continue
       if (inlCallsSelf(fn, name)) continue
@@ -2254,12 +2257,7 @@ const devirt = (ast) => {
  * @param {Array} ast
  * @returns {Array}
  */
-// Scalar transcendental helpers the auto-vectorizer rewrites to f64x2 mirrors (PPC_CALL2 in
-// src/optimize/vectorize.js). inlineOnce must NOT dissolve their call nodes when single-caller —
-// the post-phase lift needs the call to rewrite it. Keep in sync with PPC_CALL2's keys.
-const SIMD_PROTECTED = new Set(['$math.sin_core', '$math.cos_core', '$math.sin', '$math.cos', '$math.pow', '$math.atan2', '$math.hypot', '$math.log'])
-
-const inlineOnce = (ast) => {
+const inlineOnce = (ast, { pin = EMPTY_SET } = {}) => {
   if (!Array.isArray(ast) || ast[0] !== 'module') return ast
 
   // Lift primitives are shared with `inline` (defined once above buildInline). inlineOnce
@@ -2291,11 +2289,10 @@ const inlineOnce = (ast) => {
     for (const [name, fn] of funcByName) {
       if (pinned.has(name) || otherRef.has(name)) continue
       if (callRefs.get(name) !== 1) continue
-      // Keep the scalar transcendentals that the auto-vectorizer maps to f64x2 mirrors (PPC_CALL2 in
-      // src/optimize/vectorize.js): inlining a single-caller $math.atan2/hypot/log would dissolve the
-      // call node before the post-phase lift can rewrite it to $math.atan2_2/hypot_2/log_v. Keep in
-      // sync with PPC_CALL2's keys.
-      if (SIMD_PROTECTED.has(name)) continue
+      // Caller-pinned functions stay intact: inlining a single-caller helper would dissolve the
+      // call node, and a consumer may rely on it surviving (e.g. jz pins the scalar transcendentals
+      // its auto-vectorizer later rewrites to f64x2 mirrors). The policy lives with the caller.
+      if (pin.has(name)) continue
       if (callsSelf(fn, name)) continue
       // named params/locals only (we'll rename them); reject locals with types
       // we can't zero-init on block re-entry.
@@ -3867,6 +3864,10 @@ export default function optimize(ast, opts = true) {
   if (typeof ast === 'string') ast = parse(ast)   // accept WAT source directly
   const strictGuard = opts === true  // default: zero tolerance for bloat
   opts = normalize(opts)
+  // `pin`: caller-supplied function names that inlineOnce/inline must NOT dissolve. Keeps
+  // optimizer policy with the CALLER — e.g. jz pins the scalar transcendentals its own
+  // auto-vectorizer later rewrites to f64x2 mirrors, so no consumer-specific names live here.
+  opts.pin = opts.pin instanceof Set ? opts.pin : new Set(opts.pin || [])
 
   const log = opts.log ? (msg, delta) => opts.log(msg, delta) : () => {}
   const verbose = opts.verbose || opts.log
@@ -3888,7 +3889,7 @@ export default function optimize(ast, opts = true) {
     if (!opts.inline) return a
     // `inline: 'simd'` → SIMD-helper-only (jz's speed tier, avoids general bloat);
     // `inline: true` / `'all'` → general inlining of tiny functions.
-    a = inline(a, { simdOnly: opts.inline === 'simd' })
+    a = inline(a, { simdOnly: opts.inline === 'simd', pin: opts.pin })
     if (opts.propagate) a = propagate(a)
     if (opts.mergeBlocks) a = mergeBlocks(a)
     if (opts.vacuum) a = vacuum(a)
@@ -3909,7 +3910,7 @@ export default function optimize(ast, opts = true) {
     // propagate, and it would only confirm what `mayInline` already proved.
     for (let round = 0; round < 3; round++) {
       const beforeRound = clone(ast)
-      for (const [key, fn] of PASSES) if (opts[key] && key !== 'inlineOnce' && key !== 'inline' && key !== 'devirt') ast = fn(ast)
+      for (const [key, fn] of PASSES) if (opts[key] && key !== 'inlineOnce' && key !== 'inline' && key !== 'devirt') ast = fn(ast, opts)
       if (equal(beforeRound, ast)) break // fixpoint
       if (verbose) log(`  round ${round + 1} applied`)
     }
@@ -3926,7 +3927,7 @@ export default function optimize(ast, opts = true) {
   for (let round = 0; round < 3; round++) {
     beforeRound = clone(ast)
 
-    for (const [key, fn] of PASSES) if (opts[key] && key !== 'devirt' && key !== 'inline') ast = fn(ast)
+    for (const [key, fn] of PASSES) if (opts[key] && key !== 'devirt' && key !== 'inline') ast = fn(ast, opts)
     // Second propagate sweep: `inlineOnce`/`inline` (above) leave fresh
     // `(local.set $p arg) … (local.get $p)` wrappers around each inlined call;
     // re-running propagation collapses them within this same round, so the size

package/types/src/compile.d.ts

@@ -1,12 +1,13 @@
 /**
- * Converts a WebAssembly Text Format (WAT) tree to a WebAssembly binary format (WASM).
- *
- * @param {string|Array} nodes - The WAT tree or string to be compiled to WASM binary.
- * @returns {Uint8Array} The compiled WASM binary. When the WAT carries
- *   `@metadata.code.<type>` annotations, the result also exposes a `.metadata`
- *   property — `{ [type]: [[absoluteByteOffset, data], ...] }`, each offset the
- *   instruction's position in the final binary. That's the hook a source-map
- *   emitter needs to correlate generated wasm back to its source.
+ * Convert a WAT tree (or source string) to a wasm binary (Uint8Array). When the WAT carries
+ * `@metadata.code.<type>` annotations the result also exposes `.metadata` —
+ * `{ [type]: [[absByteOffset, data], ...] }`, the hook a source-map emitter needs.
  */
-export default function compile(nodes: string | any[]): Uint8Array;
+export default function compile(nodes: any): any;
+/**
+ * Byte size of `compile(nodes)` without materializing the binary — a peer transform for
+ * tooling (the optimizer's size-revert guard, size budgeting). Exactly `compile(nodes).length`,
+ * summed from section sizes instead of building them (invariant-tested).
+ */
+export function size(nodes: any): any;
 //# sourceMappingURL=compile.d.ts.map

package/types/src/compile.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"compile.d.ts","sourceRoot":"","sources":["../../src/compile.js"],"names":[],"mappings":"AAuCA;;;;;;;;;GASG;AACH,uCAPW,MAAM,QAAM,GACV,UAAU,CAkRtB"}
+{"version":3,"file":"compile.d.ts","sourceRoot":"","sources":["../../src/compile.js"],"names":[],"mappings":"AA4UA;;;;GAIG;AACH,iDAAiE;AAEjE;;;;GAIG;AACH,sCAA4D"}

package/types/src/optimize.d.ts

@@ -56,10 +56,42 @@ export function strength(ast: any[]): any[];
  */
 export function branch(ast: any[]): any[];
 export function propagate(ast: any): any;
-export function inline(ast: any, { simdOnly }?: {
+export function inline(ast: any, { simdOnly, pin }?: {
     simdOnly?: boolean;
+    pin?: any;
 }): any;
-export function inlineOnce(ast: any): any;
+/**
+ * Inline functions that are called from exactly one place into their lone caller,
+ * then delete them. Unlike {@link inline} (which duplicates tiny stateless bodies),
+ * this never duplicates code and never inflates: each inlined function drops a
+ * function-section entry, a type-section entry (if now unused), and a `call`
+ * instruction, paying back only a `block`/`local.set` wrapper. This is what
+ * `wasm-opt -Oz` does — collapsing helper chains down to a couple of functions —
+ * and it's the bulk of the gap between hand-tuned WASM and naive codegen.
+ *
+ * A function `$f` qualifies when it is, all of:
+ *  • named, with named params and locals (numeric indices can't be safely renamed);
+ *  • referenced exactly once across the whole module, by a plain `call` (no
+ *    `return_call`, `ref.func`, `elem`, `export`, or `start` reference, and not
+ *    recursive);
+ *  • single-result or void (a multi-value result can't be modeled as `(block (result …))`);
+ *  • free of numeric (depth-relative) branch labels — those would shift under the
+ *    extra block nesting — and of `return_call*` in its body.
+ *
+ * `(call $f a0 a1 …)` becomes
+ *   (block $__inlN (result T)?
+ *     (local.set $__inlN_p0 a0) (local.set $__inlN_p1 a1) …   ;; args evaluated once, in order
+ *     …body, params/locals renamed to $__inlN_*, `return X` → `br $__inlN X`…)
+ * and the renamed params+locals are appended to the caller's `local` decls; the
+ * body's own block/loop/if labels are renamed too so they can't shadow the caller's.
+ * Runs to a fixpoint so helper chains fully collapse.
+ *
+ * @param {Array} ast
+ * @returns {Array}
+ */
+export function inlineOnce(ast: any[], { pin }?: {
+    pin?: any;
+}): any[];
 /**
  * Devirtualize `call_indirect` through NaN-boxed closure values with a statically
  * known candidate set. `let f = c ? a : b; … f(x)` emits a select of two i64

package/types/src/optimize.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"optimize.d.ts","sourceRoot":"","sources":["../../src/optimize.js"],"names":[],"mappings":"AAyxHA,gEAyFC;AA9zHD;;;;GAIG;AACH,4BAHW,GAAG,GACD,MAAM,CAOlB;AAED;;;;GAIG;AACH,wCAFa,MAAM,CAIlB;AA8CD;;;;;GAKG;AACH,6CAgJC;AAwUD;;;;GAIG;AACH,wCAkDC;AA0YD;;;;GAIG;AACH,4CAqBC;AA+CD;;;;;GAKG;AACH,8CAmDC;AAndD;;;;GAIG;AACH,4CASC;AAID;;;;GAIG;AACH,4CAwDC;AAID;;;;GAIG;AACH,0CA6CC;AAuyBD,yCAqCC;AAmND;;QAqEC;AAySD,0CAgJC;AArbD;;;;;;;;;;;;;;;;;;;;;;;;GAwBG;AACH,sCAwOC;AAghDD;;;;;;;;GAQG;AACH,gCAHW,OAAO,GAAC,MAAM,MAAO,OAc/B;AAvBD,qEAAqE;AACrE,uBAA8D;AArlC9D;;;;;GAKG;AACH,0CA8DC;AA+ED;;;;GAIG;AACH,4CAQC;AAiCD;;;;;;;;;;;GAWG;AACH,2CAyDC;AAID,2EAA2E;AAC3E,sCAgEC;AAID;;;;GAIG;AACH,4CAyCC;AAID;;;;;;;;;;;;;;;;;;;;;;;GAuBG;AACH,2CAiDC;AAID;;;;;GAKG;AACH,4CAqBC;AAID;;;;;;GAMG;AACH,wCAmBC;AAID;;;;;GAKG;AACH,4CAiDC;AAoCD;;;;;GAKG;AACH,0CA8DC;AAwWD,uCAyBC;AA7XD;;;;;GAKG;AACH,8CAyEC;AA2ID;;;;GAIG;AACH,4CAyDC;AAqBD;;;;;GAKG;AACH,iDAgBC;AA/sCD;;;;;;;;;;;;;;;;;;;;;;;;;;GA0BG;AACH,+CAiFC;AAID;;;;;;;;;;;;;;;;GAgBG;AACH,kDAyFC"}
+{"version":3,"file":"optimize.d.ts","sourceRoot":"","sources":["../../src/optimize.js"],"names":[],"mappings":"AAsxHA,gEA6FC;AA/zHD;;;;GAIG;AACH,4BAHW,GAAG,GACD,MAAM,CAOlB;AAED;;;;GAIG;AACH,wCAFa,MAAM,CAOlB;AA8CD;;;;;GAKG;AACH,6CAgJC;AAwUD;;;;GAIG;AACH,wCAkDC;AA0YD;;;;GAIG;AACH,4CAqBC;AA+CD;;;;;GAKG;AACH,8CAmDC;AAndD;;;;GAIG;AACH,4CASC;AAID;;;;GAIG;AACH,4CAwDC;AAID;;;;GAIG;AACH,0CA6CC;AAuyBD,yCAqCC;AAmND;;;QAqEC;AAuQD;;;;;;;;;;;;;;;;;;;;;;;;;;;;GA4BG;AACH;;UA+IC;AA/aD;;;;;;;;;;;;;;;;;;;;;;;;GAwBG;AACH,sCAwOC;AA0gDD;;;;;;;;GAQG;AACH,gCAHW,OAAO,GAAC,MAAM,MAAO,OAc/B;AAvBD,qEAAqE;AACrE,uBAA8D;AArlC9D;;;;;GAKG;AACH,0CA8DC;AA+ED;;;;GAIG;AACH,4CAQC;AAiCD;;;;;;;;;;;GAWG;AACH,2CAyDC;AAID,2EAA2E;AAC3E,sCAgEC;AAID;;;;GAIG;AACH,4CAyCC;AAID;;;;;;;;;;;;;;;;;;;;;;;GAuBG;AACH,2CAiDC;AAID;;;;;GAKG;AACH,4CAqBC;AAID;;;;;;GAMG;AACH,wCAmBC;AAID;;;;;GAKG;AACH,4CAiDC;AAoCD;;;;;GAKG;AACH,0CA8DC;AAwWD,uCAyBC;AA7XD;;;;;GAKG;AACH,8CAyEC;AA2ID;;;;GAIG;AACH,4CAyDC;AAqBD;;;;;GAKG;AACH,iDAgBC;AA/sCD;;;;;;;;;;;;;;;;;;;;;;;;;;GA0BG;AACH,+CAiFC;AAID;;;;;;;;;;;;;;;;GAgBG;AACH,kDAyFC"}