runmat 0.3.5 → 0.4.0

package/dist/generated/builtins/xor.js

@@ -0,0 +1,148 @@
+// @generated by scripts/generate-builtins.cjs
+// Do not edit by hand.
+const builtinDoc = {
+    "title": "xor",
+    "category": "logical/bit",
+    "keywords": [
+        "logical xor",
+        "exclusive or",
+        "boolean xor",
+        "MATLAB xor",
+        "gpuArray xor"
+    ],
+    "summary": "Element-wise logical XOR for scalars, arrays, and gpuArray values.",
+    "references": [],
+    "gpu_support": {
+        "elementwise": true,
+        "reduction": false,
+        "precisions": [
+            "f32",
+            "f64"
+        ],
+        "broadcasting": "matlab",
+        "notes": "Runs entirely on the GPU when the active provider implements `logical_xor`; otherwise inputs gather back to the host automatically."
+    },
+    "fusion": {
+        "elementwise": true,
+        "reduction": false,
+        "max_inputs": 2,
+        "constants": "inline"
+    },
+    "requires_feature": null,
+    "tested": {
+        "unit": "builtins::logical::bit::xor::tests",
+        "integration": "builtins::logical::bit::xor::tests::xor_gpu_roundtrip",
+        "gpu": "builtins::logical::bit::xor::tests::xor_wgpu_matches_host_path"
+    },
+    "description": "`xor(A, B)` returns the element-wise logical exclusive OR of its inputs. The result is `true` exactly when one, and only one, operand evaluates to non-zero (with `NaN` counting as non-zero). Outputs are logical scalars when the broadcasted shape has a single element, or logical arrays otherwise.",
+    "behaviors": [
+        "Accepts logical, numeric, complex, and character arrays; character code points of zero evaluate to `false`.",
+        "Supports MATLAB-style implicit expansion so scalars and singleton dimensions broadcast automatically.",
+        "Propagates empty dimensions: if a broadcasted axis has length `0`, the output is an empty logical array with the same shape.",
+        "Treats `NaN` values as `true`, matching MATLAB's element-wise logical semantics.",
+        "Keeps `gpuArray` inputs on device when the active provider exposes the `logical_xor` hook; otherwise the runtime gathers to host transparently."
+    ],
+    "examples": [
+        {
+            "description": "Checking if exactly one condition is true",
+            "input": "result = xor(true, false)",
+            "output": "result =\n  logical\n     1"
+        },
+        {
+            "description": "Performing XOR on numeric arrays element-wise",
+            "input": "A = [1 0 2 0];\nB = [3 4 0 0];\nC = xor(A, B)",
+            "output": "C =\n  1×4 logical array\n     0     1     1     0"
+        },
+        {
+            "description": "Applying XOR with implicit expansion against a scalar",
+            "input": "mask = [1; 0; 3; 0];\nflag = xor(mask, 1)",
+            "output": "flag =\n  4×1 logical array\n     0\n     1\n     0\n     1"
+        },
+        {
+            "description": "Comparing character arrays with XOR",
+            "input": "lhs = ['R' 'u' 0];\nrhs = ['R' 0 'n'];\ndiff = xor(lhs, rhs)",
+            "output": "diff =\n  1×3 logical array\n     0     1     1"
+        },
+        {
+            "description": "Running `xor` directly on `gpuArray` inputs",
+            "input": "G1 = gpuArray([0 2 0 4]);\nG2 = gpuArray([1 0 3 4]);\ndeviceResult = xor(G1, G2);\nhostResult = gather(deviceResult)",
+            "output": "deviceResult =\n  1×4 gpuArray logical array\n     1     1     1     0\nhostResult =\n  1×4 logical array\n     1     1     1     0"
+        }
+    ],
+    "faqs": [
+        {
+            "question": "Does `xor` return logical values?",
+            "answer": "Yes. The result is a logical scalar (`true`/`false`) when the broadcasted shape contains exactly one element; otherwise the function returns a logical array. On the GPU the kernel writes `0.0`/`1.0` elements, and the runtime converts them back to logical values when you gather."
+        },
+        {
+            "question": "How are `NaN` values handled?",
+            "answer": "`NaN` counts as `true`. For example, `xor(NaN, 5)` returns `false` because both operands evaluate to non-zero, whereas `xor(NaN, 0)` returns `true`."
+        },
+        {
+            "question": "Is implicit expansion supported?",
+            "answer": "Yes. The inputs follow MATLAB-style implicit expansion rules: dimensions of length `1` broadcast across the other input. Fully incompatible shapes raise a size-mismatch error."
+        },
+        {
+            "question": "Can I use `xor` with complex numbers?",
+            "answer": "Yes. Real or complex inputs return `true` when exactly one operand has a non-zero real or imaginary component. For example, `xor(0 + 0i, 0 + 2i)` returns `true`, while `xor(1 + 0i, 0 + 2i)` returns `false`."
+        },
+        {
+            "question": "What happens when only one input is a `gpuArray`?",
+            "answer": "RunMat promotes the other input to the GPU before dispatch when the auto-offload planner decides it is profitable. If the provider lacks a device implementation, both operands gather to host automatically and the logical result executes on the CPU."
+        },
+        {
+            "question": "What does xor do in MATLAB?",
+            "answer": "`xor(A, B)` returns logical `true` where exactly one of `A` or `B` is nonzero, and `false` where both are zero or both are nonzero. The result is always a logical array."
+        },
+        {
+            "question": "How is xor different from or in MATLAB?",
+            "answer": "`or(A, B)` (i.e. `A | B`) returns `true` when either or both inputs are nonzero. `xor(A, B)` returns `true` only when exactly one input is nonzero — it is `false` when both are true."
+        },
+        {
+            "question": "Can I use xor with more than two inputs?",
+            "answer": "`xor` accepts exactly two inputs. To XOR multiple arrays, chain calls: `xor(xor(A, B), C)`. This computes the parity (true when an odd number of inputs are true)."
+        },
+        {
+            "question": "Does xor support GPU arrays in RunMat?",
+            "answer": "Yes. `xor` runs on the GPU with elementwise fusion and implicit expansion. Both inputs can be GPU arrays or one can be a scalar."
+        }
+    ],
+    "links": [
+        {
+            "label": "and",
+            "url": "./and"
+        },
+        {
+            "label": "or",
+            "url": "./or"
+        },
+        {
+            "label": "gpuArray",
+            "url": "./gpuarray"
+        },
+        {
+            "label": "gather",
+            "url": "./gather"
+        },
+        {
+            "label": "not",
+            "url": "./not"
+        }
+    ],
+    "source": {
+        "label": "`crates/runmat-runtime/src/builtins/logical/bit/xor.rs`",
+        "url": "https://github.com/runmat-org/runmat/blob/main/crates/runmat-runtime/src/builtins/logical/bit/xor.rs"
+    },
+    "gpu_residency": "You usually do **not** need to call `gpuArray` explicitly. RunMat's native auto-offload logic moves data to the GPU when a fused expression benefits from device execution, and results stay resident until you gather them or the planner needs host access. Call `gpuArray` only when you want to seed residency manually, or when you are porting MATLAB code that already uses explicit device transfers.",
+    "gpu_behavior": [
+        "When both operands reside on the GPU and the active provider implements the `logical_xor` hook, RunMat lowers the call into a device kernel that writes `0` or `1` for each element. The fusion planner treats `xor` as an element-wise operation, so fused expressions (for example, `xor(A > 0, B)`) stay on device without intermediate gathers. The native auto-offload planner also recognizes the builtin's `elementwise` tag, promoting mixed CPU/GPU operands to the active device when it is profitable. If the provider lacks the hook, the runtime gathers the inputs to host memory automatically and executes the CPU implementation instead of failing."
+    ],
+    "key": "xor",
+    "slug": "xor",
+    "categoryPath": [
+        "logical",
+        "bit"
+    ]
+};
+export default builtinDoc;
+//# sourceMappingURL=xor.js.map

package/dist/generated/builtins/xor.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"xor.js","sourceRoot":"","sources":["../../../src/generated/builtins/xor.ts"],"names":[],"mappings":"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"}

package/dist/generated/builtins/zeros.d.ts

@@ -0,0 +1,4 @@
+import type { BuiltinDoc } from "../../builtins.js";
+declare const builtinDoc: BuiltinDoc;
+export default builtinDoc;
+//# sourceMappingURL=zeros.d.ts.map

package/dist/generated/builtins/zeros.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"zeros.d.ts","sourceRoot":"","sources":["../../../src/generated/builtins/zeros.ts"],"names":[],"mappings":"AAGA,OAAO,KAAK,EAAE,UAAU,EAAE,MAAM,mBAAmB,CAAC;AAEpD,QAAA,MAAM,UAAU,EAAE,UA0LjB,CAAC;AAEF,eAAe,UAAU,CAAC"}

package/dist/generated/builtins/zeros.js

@@ -0,0 +1,191 @@
+// @generated by scripts/generate-builtins.cjs
+// Do not edit by hand.
+const builtinDoc = {
+    "title": "zeros",
+    "category": "array/creation",
+    "keywords": [
+        "zeros",
+        "array",
+        "logical",
+        "gpu",
+        "like"
+    ],
+    "summary": "Create arrays filled with zeros within the MATLAB language.",
+    "references": [],
+    "gpu_support": {
+        "elementwise": false,
+        "reduction": false,
+        "precisions": [
+            "f32",
+            "f64"
+        ],
+        "broadcasting": "none",
+        "notes": "Uses provider zero-allocation hooks when available; otherwise falls back to uploading a host tensor."
+    },
+    "fusion": {
+        "elementwise": false,
+        "reduction": false,
+        "max_inputs": 0,
+        "constants": "inline"
+    },
+    "requires_feature": null,
+    "tested": {
+        "unit": "builtins::array::zeros::tests",
+        "integration": "builtins::array::zeros::tests::zeros_gpu_like_alloc"
+    },
+    "description": "`zeros` creates arrays filled with zeros. RunMat mirrors MATLAB semantics across the scalar, vector, matrix, and N-D forms, including `'like'` and `'logical'` options.",
+    "behaviors": [
+        "`zeros()` returns the scalar `0`.",
+        "`zeros(n)` returns an `n × n` double array.",
+        "`zeros(m, n, ...)` returns a dense double array with the requested dimensions.",
+        "`zeros(sz)` accepts a size vector (row or column) and returns an array with `prod(sz)` elements arranged using MATLAB column-major ordering.",
+        "`zeros(A)` returns an array of zeros with the same size (and device residency) as `A`.",
+        "`zeros(___, 'logical')` returns a logical array instead of double precision.",
+        "`zeros(___, 'like', prototype)` matches the device residency and numeric/logical flavour of `prototype`."
+    ],
+    "examples": [
+        {
+            "description": "Creating a 2x3 matrix of zeros",
+            "input": "A = zeros(2, 3)",
+            "output": "A = [0 0 0; 0 0 0]"
+        },
+        {
+            "description": "Creating a 4x1 logical matrix of zeros",
+            "input": "mask = zeros(4, 1, 'logical')",
+            "output": "mask = [0 0 0 0]"
+        },
+        {
+            "description": "Creating a 128x128 matrix of zeros on a GPU",
+            "input": "H = zeros(128, 128)",
+            "output": "H = [0 0 0 ... 0; 0 0 0 ... 0; ...; 0 0 0 ... 0]"
+        }
+    ],
+    "faqs": [
+        {
+            "question": "When should I use the `zeros` function?",
+            "answer": "Use `zeros` whenever you need to create arrays pre-filled with the value `0`, such as for initializing weights, creating masks, or testing other algorithms. Preallocating with `zeros` ensures correct type and shape throughout your code and helps prevent bugs caused by uninitialized arrays."
+        },
+        {
+            "question": "Does `zeros` produce double arrays by default?",
+            "answer": "Yes, by default, `zeros` creates dense double-precision arrays unless you explicitly specify a type such as `'logical'` or use the `'like'` argument to match a prototype array."
+        },
+        {
+            "question": "What does `zeros(n)` return?",
+            "answer": "`zeros(n)` returns an `n × n` dense double-precision matrix filled with zeros. For example, `zeros(3)` yields a 3-by-3 matrix of all zeros."
+        },
+        {
+            "question": "How do I create a logical array of zeros?",
+            "answer": "Pass `'logical'` as the last argument:\n```matlab:runnable\nmask = zeros(5, 1, 'logical');\n```\nThis produces a 5x1 logical array, i.e., all elements have value `false` (`0` in binary)."
+        },
+        {
+            "question": "How do I match the type and device residency of an existing array?",
+            "answer": "Use the `'like', prototype` syntax:\n```matlab:runnable\nA = gpuArray(rand(2,2));\nB = zeros(2, 2, 'like', A);\n```\n`B` will be a GPU array with the same type and shape as `A`."
+        },
+        {
+            "question": "Can I create N-dimensional arrays with zeros?",
+            "answer": "Yes! Pass more than two dimension arguments (or a size vector):\n```matlab:runnable\nT = zeros(2, 3, 4);\n```\nThis creates a 2×3×4 tensor of zeros."
+        },
+        {
+            "question": "How does `zeros(A)` behave?",
+            "answer": "If you call `zeros(A)`, where `A` is an array, the result is a new array of zeros with the same shape as `A`."
+        },
+        {
+            "question": "Is the output always dense?",
+            "answer": "Yes. `zeros` always produces a dense array. For sparse matrices of zeros, use `sparse` with appropriate arguments."
+        },
+        {
+            "question": "What if I call `zeros` with no arguments?",
+            "answer": "`zeros()` returns the scalar value `0`."
+        },
+        {
+            "question": "Can I use `zeros` to preallocate arrays for later assignment?",
+            "answer": "Absolutely. Preallocating with `zeros` (or `ones`) and then filling in values is a recommended practice for efficiency and code clarity when the final values are known to overwrite the initial zeros."
+        }
+    ],
+    "links": [
+        {
+            "label": "ones",
+            "url": "./ones"
+        },
+        {
+            "label": "eye",
+            "url": "./eye"
+        },
+        {
+            "label": "gpuArray",
+            "url": "./gpuarray"
+        },
+        {
+            "label": "gather",
+            "url": "./gather"
+        },
+        {
+            "label": "colon",
+            "url": "./colon"
+        },
+        {
+            "label": "false",
+            "url": "./false"
+        },
+        {
+            "label": "fill",
+            "url": "./fill"
+        },
+        {
+            "label": "linspace",
+            "url": "./linspace"
+        },
+        {
+            "label": "logspace",
+            "url": "./logspace"
+        },
+        {
+            "label": "magic",
+            "url": "./magic"
+        },
+        {
+            "label": "meshgrid",
+            "url": "./meshgrid"
+        },
+        {
+            "label": "rand",
+            "url": "./rand"
+        },
+        {
+            "label": "randi",
+            "url": "./randi"
+        },
+        {
+            "label": "randn",
+            "url": "./randn"
+        },
+        {
+            "label": "randperm",
+            "url": "./randperm"
+        },
+        {
+            "label": "range",
+            "url": "./range"
+        },
+        {
+            "label": "true",
+            "url": "./true"
+        }
+    ],
+    "source": {
+        "label": "`crates/runmat-runtime/src/builtins/array/creation/zeros.rs`",
+        "url": "https://github.com/runmat-org/runmat/blob/main/crates/runmat-runtime/src/builtins/array/creation/zeros.rs"
+    },
+    "gpu_residency": "You usually do NOT need to call `gpuArray` yourself in RunMat (unlike MATLAB).\n\nIn RunMat, the fusion planner keeps residency on GPU in branches of fused expressions. As such, in the above example, the result of the `zeros` call will already be on the GPU when the fusion planner has detected a net benefit to operating the fused expression it is part of on the GPU.\n\nTo preserve backwards compatibility with MathWorks MATLAB, and for when you want to explicitly bootstrap GPU residency, you can call `gpuArray` explicitly to move data to the GPU if you want to be explicit about the residency.\n\nSince MathWorks MATLAB does not have a fusion planner, and they kept their parallel execution toolbox separate from the core language, as their toolbox is a separate commercial product, MathWorks MATLAB users need to call `gpuArray` to move data to the GPU manually whereas RunMat users can rely on the fusion planner to keep data on the GPU automatically.",
+    "gpu_behavior": [
+        "When the prototype or `'like'` argument is a GPU tensor, RunMat asks the active acceleration provider to allocate a zero-filled buffer in-place. Providers that do not yet support the zero allocation hooks automatically fall back to uploading a host zero tensor, guaranteeing correct behaviour at the cost of an extra transfer."
+    ],
+    "key": "zeros",
+    "slug": "zeros",
+    "categoryPath": [
+        "array",
+        "creation"
+    ]
+};
+export default builtinDoc;
+//# sourceMappingURL=zeros.js.map

package/dist/generated/builtins/zeros.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"zeros.js","sourceRoot":"","sources":["../../../src/generated/builtins/zeros.ts"],"names":[],"mappings":"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"}

package/dist/generated/builtins/zlabel.d.ts

@@ -0,0 +1,4 @@
+import type { BuiltinDoc } from "../../builtins.js";
+declare const builtinDoc: BuiltinDoc;
+export default builtinDoc;
+//# sourceMappingURL=zlabel.d.ts.map

package/dist/generated/builtins/zlabel.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"zlabel.d.ts","sourceRoot":"","sources":["../../../src/generated/builtins/zlabel.ts"],"names":[],"mappings":"AAGA,OAAO,KAAK,EAAE,UAAU,EAAE,MAAM,mBAAmB,CAAC;AAEpD,QAAA,MAAM,UAAU,EAAE,UAmEjB,CAAC;AAEF,eAAe,UAAU,CAAC"}

package/dist/generated/builtins/zlabel.js

@@ -0,0 +1,72 @@
+// @generated by scripts/generate-builtins.cjs
+// Do not edit by hand.
+const builtinDoc = {
+    "title": "zlabel",
+    "category": "plotting",
+    "keywords": [
+        "zlabel",
+        "z-axis label",
+        "3-D axis label",
+        "matlab zlabel",
+        "surface axis labeling"
+    ],
+    "summary": "Set z-axis labels for 3-D plots, surfaces, and MATLAB `zlabel` workflows.",
+    "requires_feature": null,
+    "tested": {
+        "unit": "builtins::plotting::zlabel::tests"
+    },
+    "description": "`zlabel` sets or updates the z-axis label for the current axes or an explicit axes handle. In RunMat it returns a text handle, stores the label as subplot-local axes metadata, and supports the same multiline/property workflows as the other shared text builtins used for titles and axis labels.",
+    "behaviors": [
+        "The returned value is a text handle that can be queried and updated through `get` and `set`.",
+        "String scalars, string arrays, and cell arrays can all be used to build multiline z-axis labels in MATLAB-style workflows.",
+        "Font and text styling properties flow through the shared plotting text-property system, so `get` and `set` work on the returned handle.",
+        "Z-axis labels are subplot-local and stay attached to the axes they were created for."
+    ],
+    "examples": [
+        {
+            "description": "Add a z-axis label to a surface plot",
+            "input": "[X, Y] = meshgrid(linspace(-3, 3, 50), linspace(-3, 3, 50));\nZ = sin(X) .* cos(Y);\nsurf(X, Y, Z);\nzlabel('Height');"
+        },
+        {
+            "description": "Create a multiline z-axis label and style it",
+            "input": "[X, Y] = meshgrid(-2:0.2:2, -2:0.2:2);\nZ = X .* exp(-X.^2 - Y.^2);\nsurf(X, Y, Z);\nh = zlabel([\"Depth\", \"(km)\"]);\nset(h, 'FontWeight', 'bold');"
+        },
+        {
+            "description": "Target a specific subplot axes",
+            "input": "[X, Y] = meshgrid(linspace(-3, 3, 30), linspace(-3, 3, 30));\nZ = sin(X) .* cos(Y);\nsubplot(1, 2, 1);\nsurf(X, Y, Z);\nax = subplot(1, 2, 2);\nplot3(cos(0:0.1:5), sin(0:0.1:5), 0:0.1:5);\nzlabel(ax, 'Trajectory Height');"
+        }
+    ],
+    "links": [
+        {
+            "label": "view",
+            "url": "./view"
+        },
+        {
+            "label": "plot3",
+            "url": "./plot3"
+        },
+        {
+            "label": "surf",
+            "url": "./surf"
+        },
+        {
+            "label": "get",
+            "url": "./get"
+        },
+        {
+            "label": "set",
+            "url": "./set"
+        }
+    ],
+    "source": {
+        "label": "`crates/runmat-runtime/src/builtins/plotting/ops/zlabel.rs`",
+        "url": "https://github.com/runmat-org/runmat/blob/main/crates/runmat-runtime/src/builtins/plotting/ops/zlabel.rs"
+    },
+    "key": "zlabel",
+    "slug": "zlabel",
+    "categoryPath": [
+        "plotting"
+    ]
+};
+export default builtinDoc;
+//# sourceMappingURL=zlabel.js.map

package/dist/generated/builtins/zlabel.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"zlabel.js","sourceRoot":"","sources":["../../../src/generated/builtins/zlabel.ts"],"names":[],"mappings":"AAAA,8CAA8C;AAC9C,uBAAuB;AAIvB,MAAM,UAAU,GAAe;IAC7B,OAAO,EAAE,QAAQ;IACjB,UAAU,EAAE,UAAU;IACtB,UAAU,EAAE;QACV,QAAQ;QACR,cAAc;QACd,gBAAgB;QAChB,eAAe;QACf,uBAAuB;KACxB;IACD,SAAS,EAAE,2EAA2E;IACtF,kBAAkB,EAAE,IAAI;IACxB,QAAQ,EAAE;QACR,MAAM,EAAE,mCAAmC;KAC5C;IACD,aAAa,EAAE,uSAAuS;IACtT,WAAW,EAAE;QACX,8FAA8F;QAC9F,4HAA4H;QAC5H,yIAAyI;QACzI,sFAAsF;KACvF;IACD,UAAU,EAAE;QACV;YACE,aAAa,EAAE,sCAAsC;YACrD,OAAO,EAAE,wHAAwH;SAClI;QACD;YACE,aAAa,EAAE,8CAA8C;YAC7D,OAAO,EAAE,wJAAwJ;SAClK;QACD;YACE,aAAa,EAAE,gCAAgC;YAC/C,OAAO,EAAE,+NAA+N;SACzO;KACF;IACD,OAAO,EAAE;QACP;YACE,OAAO,EAAE,MAAM;YACf,KAAK,EAAE,QAAQ;SAChB;QACD;YACE,OAAO,EAAE,OAAO;YAChB,KAAK,EAAE,SAAS;SACjB;QACD;YACE,OAAO,EAAE,MAAM;YACf,KAAK,EAAE,QAAQ;SAChB;QACD;YACE,OAAO,EAAE,KAAK;YACd,KAAK,EAAE,OAAO;SACf;QACD;YACE,OAAO,EAAE,KAAK;YACd,KAAK,EAAE,OAAO;SACf;KACF;IACD,QAAQ,EAAE;QACR,OAAO,EAAE,6DAA6D;QACtE,KAAK,EAAE,0GAA0G;KAClH;IACD,KAAK,EAAE,QAAQ;IACf,MAAM,EAAE,QAAQ;IAChB,cAAc,EAAE;QACd,UAAU;KACX;CACF,CAAC;AAEF,eAAe,UAAU,CAAC"}

package/dist/generated/builtins-manifest.d.ts

@@ -0,0 +1,5 @@
+import type { BuiltinDocLoader, BuiltinManifestEntry } from "../builtins.js";
+export declare const builtinManifest: BuiltinManifestEntry[];
+export declare const builtinDocLoaders: Record<string, BuiltinDocLoader>;
+export declare const builtinExamplesCatalogLoader: () => Promise<import("../builtins.js").BuiltinExampleCatalogEntry[]>;
+//# sourceMappingURL=builtins-manifest.d.ts.map

package/dist/generated/builtins-manifest.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"builtins-manifest.d.ts","sourceRoot":"","sources":["../../src/generated/builtins-manifest.ts"],"names":[],"mappings":"AAGA,OAAO,KAAK,EAAE,gBAAgB,EAAE,oBAAoB,EAAE,MAAM,gBAAgB,CAAC;AAE7E,eAAO,MAAM,eAAe,EAAE,oBAAoB,EA2zMjD,CAAC;AAEF,eAAO,MAAM,iBAAiB,EAAE,MAAM,CAAC,MAAM,EAAE,gBAAgB,CAgV9D,CAAC;AAEF,eAAO,MAAM,4BAA4B,sEAC0C,CAAC"}