@renju-note/quintet 0.10.4 → 0.11.0

package/README.md

@@ -1,54 +1,114 @@
 # quintet
 
-Renju mate solver compilable to WebAssembly
+A [Renju](https://www.renju.net/rifrules/) mate solver written in Rust and
+compiled to WebAssembly. Given a position and a side to move, it searches for
+a forced win and returns the winning sequence.
 
-## Run
+quintet powers the analysis features of [renju-note](https://github.com/renju-note),
+and is published to npm as
+[`@renju-note/quintet`](https://www.npmjs.com/package/@renju-note/quintet).
 
-### VCF
+## What it solves
 
+| Mode | Meaning |
+| --- | --- |
+| **VCF** (Victory by Continuous Fours) | A forced win using only *fours*: every attacking move threatens to complete five, so every reply is forced. |
+| **VCT** (Victory by Continuous Threats) | A forced win using *fours and threes*. The defender may answer a three in several ways, so this is a proper AND/OR tree search, solved with proof numbers. |
+
+Renju rules are fully modelled: Black's forbidden moves (double-three,
+double-four, overline) are detected — including the recursive "real vs. fake
+three" rule — and can be both an obstacle for a Black attacker and a winning
+resource for a White attacker. Opening restrictions and passing are not
+modelled; the solver takes an arbitrary position.
+
+## Usage
+
+### From JavaScript
+
+```sh
+npm install @renju-note/quintet
 ```
-% cargo run --release --example solve vcf 10 5 x \
-  H8,H7,F6,G7,I7,G9,G6,H6,F8,E8,F9,F7,E7,D6,H4,G5,J6,I5,J4,K5,J5,J3,J8,J7,I4,K4,K6,L7,L6,M6,I2,N7,L5,K7,M7,G4,I8,G8,K8,L8,D5,E4,F4,F3,H3,G2,E2,I10,J11,F11,G11,D9,E10,E12,F13,C10,B11,C12,D12
-    Finished release [optimized] target(s) in 0.00s
-     Running `target/release/examples/solve vcf 10 x H8,H7,F6,G7,I7,G9,G6,H6,F8,E8,F9,F7,E7,D6,H4,G5,J6,I5,J4,K5,J5,J3,J8,J7,I4,K4,K6,L7,L6,M6,I2,N7,L5,K7,M7,G4,I8,G8,K8,L8,D5,E4,F4,F3,H3,G2,E2,I10,J11,F11,G11,D9,E10,E12,F13,C10,B11,C12,D12`
-Kind: VCF
-MaxDepth: 10
-Player: White
-Board:
-15 . . . . . . . . . . . . . . .
-14 . . . . . . . . . . . . . . .
-13 . . . . . o . . . . . . . . .
-12 . . x o x . . . . . . . . . .
-11 . o . . . x o . . o . . . . .
-10 . . x . o . . . x . . . . . .
- 9 . . . x . o x . . . . . . . .
- 8 . . . . x o x o o o o x . . .
- 7 . . . . o x x x o x x x o x .
- 6 . . . x . o o x . o o o x . .
- 5 . . . o . . x . x o x o . . .
- 4 . . . . x o x o o o x . . . .
- 3 . . . . . x . o . x . . . . .
- 2 . . . . o . x . o . . . . . .
- 1 . . . . . . . . . . . . . . .
-   A B C D E F G H I J K L M N O
 
-Solving...
+```js
+import init, { solve_vct_dfpn, encode_xy, decode_x, decode_y } from "@renju-note/quintet";
 
-Elapsed: 45.041µs
-Depth: 8
-Solution: G1,G3,E6,H9,H5,I6,F5,E5,C8,D7,C11,C9,C14,C13,D13
+await init();
+
+// Points are encoded as a single byte: x * 15 + y, with x, y in 0..15
+// (x = column A..O, y = row 1..15).
+const blacks = [encode_xy(7, 7), encode_xy(7, 6)]; // H8, H7
+const whites = [encode_xy(6, 6)];                  // G7
+
+// solve_vct_dfpn(blacks, whites, blackToMove, limit) -> Uint8Array | undefined
+const path = solve_vct_dfpn(blacks, whites, true, 10);
+if (path) {
+  const moves = Array.from(path, (p) => [decode_x(p), decode_y(p)]);
+  // moves alternates attacker, defender, attacker, ...
+}
 ```
 
-### VCT
+Exported functions (`src/wasm.rs`):
+
+| Function | Description |
+| --- | --- |
+| `solve(mode, limit, blacks, whites, black, threat_limit)` | General entry point. `mode` is a numeric `SolveMode` code: `0` = VCF, `10` = VCT (DFS), `15` = VCT (PNS), `16` = VCT (df-pn). |
+| `solve_vcf(blacks, whites, black, limit)` | Shorthand for `mode = 0`. |
+| `solve_vct(blacks, whites, black, limit)` | Shorthand for `mode = 10`, `threat_limit = limit`. |
+| `solve_vct_dfpn(blacks, whites, black, limit)` | Shorthand for `mode = 16`, `threat_limit = limit`. The recommended VCT solver. |
+| `encode_xy(x, y)` / `decode_x(code)` / `decode_y(code)` | Point encoding helpers. |
+
+All solvers return the winning path as encoded points, or nothing if no win
+is found within the limits.
+
+### From Rust
+
+```toml
+[dependencies]
+quintet = { git = "https://github.com/renju-note/quintet" }
+```
+
+```rust
+use quintet::board::*;
+use quintet::mate::*;
+
+let board: Board = "H8,H7,F6".parse()?; // moves alternating Black, White, ...
+let mate = solve(SolveMode::VCTDFPNS, 10, &board, Player::Black, 3);
+if let Some(m) = mate {
+    println!("{}", Points(m.path));
+}
+```
+
+### Parameters
+
+- **`limit`** — maximum number of *attacker* moves in the solution. Larger
+  values find longer wins but take longer.
+- **`threat_limit`** — depth of the nested VCF search used to decide whether
+  a move is a threat (VCT only). `1` recognises only fours and threes as
+  threats; higher values also find "hidden" threats that prepare a
+  four-three.
+
+### Command line
+
+`examples/solve.rs` wraps the solver for quick experiments:
+
+```sh
+cargo run --release --example solve <mode> <limit> <threat_limit> <o|x> <position>
+```
+
+- `mode`: `vcf`, `vct`, `vct_pns` or `vct_dfpns`
+- `o|x`: the attacker (`o` = Black, `x` = White)
+- `position`: a move list `H8,H7,F6,...` (alternating from Black), or a
+  stone list `H8,F6/H7` written as `blacks/whites`
+
+Example — White has a 15-move VCT ending in a forbidden move for Black:
 
 ```
 % cargo run --release --example solve vct_dfpns 255 3 x \
   H8,I9,H7,J8,F8,H9,G9,H10,G11,F10,I10,G10,I8,J9,E10,K9,L9,G8,J10,K7,L6,K8,K6,L10,I7,J6,M9,I5,H4,F7,G6,E6,D5,F5,G4
-    Finished release [optimized] target(s) in 0.03s
-     Running `target/release/examples/solve vct_dfpn 255 x H8,I9,H7,J8,F8,H9,G9,H10,G11,F10,I10,G10,I8,J9,E10,K9,L9,G8,J10,K7,L6,K8,K6,L10,I7,J6,M9,I5,H4,F7,G6,E6,D5,F5,G4`
-Kind: VCTDFPN
-MaxDepth: 255
-Player: White
+Mode: VCTDFPNS
+Limit: 255
+ThreatLimit: 3
+Attacker: White
 Board:
 15 . . . . . . . . . . . . . . .
 14 . . . . . . . . . . . . . . .
@@ -69,21 +129,57 @@ Board:
 
 Solving...
 
-Elapsed: 2.370459s
-Depth: 17
-Solution: K11,K10,N12,M11,N8,H5,H6,L8,J5,J7,M5,L4,M6,K5,N7,N5,M4,M7,J4,I6,F3,M8,M10,I12,J11,K3,K4,J3,O8,L5,M2,M3,N1
+Elapsed: 889.191875ms
+End: Forbidden(L7)
+Times (Length): 15 (29)
+Moves: K11,K10,N12,M11,N8,H5,H6,L8,J5,J7,M5,L4,M6,K5,J4,K3,J3,J2,K4,L5,M4,L3,L2,F3,I6,E2,D1,M3,N5
 ```
 
-Original game: https://www.renju.net/media/games.php?gameid=92337
+(Original game: <https://www.renju.net/media/games.php?gameid=92337>)
 
-## Release
+## How it works
+
+- `src/board/` — bit-packed board representation. Every rule concept (five,
+  four, three, forbidden move) is detected by sliding a 5-cell window over
+  bitmask lines.
+- `src/mate/vcf/` — depth-first VCF search over four-making moves, with a
+  transposition memo.
+- `src/mate/vct/` — VCT search as a proof-number AND/OR tree. The DFS, PNS
+  and df-pn variants share one solver and differ only in their threshold
+  policy. Threats are recognised by running a nested VCF search after a
+  hypothetical pass.
+- `src/analysis/` — potential-field heuristics used for move ordering.
+- `src/wasm.rs` — the `wasm-bindgen` surface.
+
+The [`docs/`](docs/README.en.md) directory has detailed documentation in
+English and Japanese: the Renju rules, how the board code implements them,
+and how the solvers work.
 
+## Development
+
+```sh
+cargo test --release                      # always test in release; the solvers are slow in debug
+cargo test --release -- --ignored         # also run the slow benchmark cases
+cargo fmt --check
+cargo clippy --all-targets -- -D warnings
+cargo build --target wasm32-unknown-unknown
 ```
-# build
-$ wasm-pack build --scope renju-note
 
-# publish
-$ wasm-pack publish
+Everything under `src/` must stay compilable for `wasm32-unknown-unknown`:
+no threads, no filesystem, no `std::time` in library code.
+
+## Release
+
+Publishing a GitHub release triggers
+[`.github/workflows/wasm-pack-release.yml`](.github/workflows/wasm-pack-release.yml),
+which sets the crate version from the tag (`vX.Y.Z`), runs
+`wasm-pack build --scope renju-note` and publishes the package to npm with
+trusted publishing. To build the package locally:
+
+```sh
+wasm-pack build --scope renju-note
 ```
 
-See also: https://developer.mozilla.org/ja/docs/WebAssembly/Rust_to_wasm
+## License
+
+[MIT](LICENSE)

package/package.json

@@ -1,10 +1,11 @@
 {
   "name": "@renju-note/quintet",
+  "type": "module",
   "collaborators": [
     "yubessy <yubessy0@gmail.com>"
   ],
   "description": "Renju mate solver compilable to WebAssemby",
-  "version": "0.10.4",
+  "version": "0.11.0",
   "license": "MIT",
   "repository": {
     "type": "git",
@@ -16,10 +17,10 @@
     "quintet_bg.js",
     "quintet.d.ts"
   ],
-  "module": "quintet.js",
+  "main": "quintet.js",
   "types": "quintet.d.ts",
   "sideEffects": [
     "./quintet.js",
     "./snippets/*"
   ]
-}
+}

package/quintet.d.ts

@@ -1,52 +1,16 @@
 /* tslint:disable */
 /* eslint-disable */
-/**
-* @param {number} mode
-* @param {number} limit
-* @param {Uint8Array} blacks
-* @param {Uint8Array} whites
-* @param {boolean} black
-* @param {number} threat_limit
-* @returns {Uint8Array | undefined}
-*/
+
+export function decode_x(code: number): number;
+
+export function decode_y(code: number): number;
+
+export function encode_xy(x: number, y: number): number;
+
 export function solve(mode: number, limit: number, blacks: Uint8Array, whites: Uint8Array, black: boolean, threat_limit: number): Uint8Array | undefined;
-/**
-* @param {Uint8Array} blacks
-* @param {Uint8Array} whites
-* @param {boolean} black
-* @param {number} limit
-* @returns {Uint8Array | undefined}
-*/
+
 export function solve_vcf(blacks: Uint8Array, whites: Uint8Array, black: boolean, limit: number): Uint8Array | undefined;
-/**
-* @param {Uint8Array} blacks
-* @param {Uint8Array} whites
-* @param {boolean} black
-* @param {number} limit
-* @returns {Uint8Array | undefined}
-*/
+
 export function solve_vct(blacks: Uint8Array, whites: Uint8Array, black: boolean, limit: number): Uint8Array | undefined;
-/**
-* @param {Uint8Array} blacks
-* @param {Uint8Array} whites
-* @param {boolean} black
-* @param {number} limit
-* @returns {Uint8Array | undefined}
-*/
+
 export function solve_vct_dfpn(blacks: Uint8Array, whites: Uint8Array, black: boolean, limit: number): Uint8Array | undefined;
-/**
-* @param {number} x
-* @param {number} y
-* @returns {number}
-*/
-export function encode_xy(x: number, y: number): number;
-/**
-* @param {number} code
-* @returns {number}
-*/
-export function decode_x(code: number): number;
-/**
-* @param {number} code
-* @returns {number}
-*/
-export function decode_y(code: number): number;

package/quintet.js

@@ -1,4 +1,9 @@
+/* @ts-self-types="./quintet.d.ts" */
 import * as wasm from "./quintet_bg.wasm";
 import { __wbg_set_wasm } from "./quintet_bg.js";
+
 __wbg_set_wasm(wasm);
-export * from "./quintet_bg.js";
+wasm.__wbindgen_start();
+export {
+    decode_x, decode_y, encode_xy, solve, solve_vcf, solve_vct, solve_vct_dfpn
+} from "./quintet_bg.js";

package/quintet_bg.js

@@ -1,179 +1,149 @@
-let wasm;
-export function __wbg_set_wasm(val) {
-    wasm = val;
-}
-
-
-let cachedUint8Memory0 = null;
-
-function getUint8Memory0() {
-    if (cachedUint8Memory0 === null || cachedUint8Memory0.byteLength === 0) {
-        cachedUint8Memory0 = new Uint8Array(wasm.memory.buffer);
-    }
-    return cachedUint8Memory0;
+/**
+ * @param {number} code
+ * @returns {number}
+ */
+export function decode_x(code) {
+    const ret = wasm.decode_x(code);
+    return ret;
 }
 
-let WASM_VECTOR_LEN = 0;
-
-function passArray8ToWasm0(arg, malloc) {
-    const ptr = malloc(arg.length * 1, 1) >>> 0;
-    getUint8Memory0().set(arg, ptr / 1);
-    WASM_VECTOR_LEN = arg.length;
-    return ptr;
+/**
+ * @param {number} code
+ * @returns {number}
+ */
+export function decode_y(code) {
+    const ret = wasm.decode_y(code);
+    return ret;
 }
 
-let cachedInt32Memory0 = null;
-
-function getInt32Memory0() {
-    if (cachedInt32Memory0 === null || cachedInt32Memory0.byteLength === 0) {
-        cachedInt32Memory0 = new Int32Array(wasm.memory.buffer);
-    }
-    return cachedInt32Memory0;
+/**
+ * @param {number} x
+ * @param {number} y
+ * @returns {number}
+ */
+export function encode_xy(x, y) {
+    const ret = wasm.encode_xy(x, y);
+    return ret;
 }
 
-function getArrayU8FromWasm0(ptr, len) {
-    ptr = ptr >>> 0;
-    return getUint8Memory0().subarray(ptr / 1, ptr / 1 + len);
-}
 /**
-* @param {number} mode
-* @param {number} limit
-* @param {Uint8Array} blacks
-* @param {Uint8Array} whites
-* @param {boolean} black
-* @param {number} threat_limit
-* @returns {Uint8Array | undefined}
-*/
+ * @param {number} mode
+ * @param {number} limit
+ * @param {Uint8Array} blacks
+ * @param {Uint8Array} whites
+ * @param {boolean} black
+ * @param {number} threat_limit
+ * @returns {Uint8Array | undefined}
+ */
 export function solve(mode, limit, blacks, whites, black, threat_limit) {
-    try {
-        const retptr = wasm.__wbindgen_add_to_stack_pointer(-16);
-        const ptr0 = passArray8ToWasm0(blacks, wasm.__wbindgen_malloc);
-        const len0 = WASM_VECTOR_LEN;
-        const ptr1 = passArray8ToWasm0(whites, wasm.__wbindgen_malloc);
-        const len1 = WASM_VECTOR_LEN;
-        wasm.solve(retptr, mode, limit, ptr0, len0, ptr1, len1, black, threat_limit);
-        var r0 = getInt32Memory0()[retptr / 4 + 0];
-        var r1 = getInt32Memory0()[retptr / 4 + 1];
-        let v3;
-        if (r0 !== 0) {
-            v3 = getArrayU8FromWasm0(r0, r1).slice();
-            wasm.__wbindgen_free(r0, r1 * 1, 1);
-        }
-        return v3;
-    } finally {
-        wasm.__wbindgen_add_to_stack_pointer(16);
+    const ptr0 = passArray8ToWasm0(blacks, wasm.__wbindgen_malloc);
+    const len0 = WASM_VECTOR_LEN;
+    const ptr1 = passArray8ToWasm0(whites, wasm.__wbindgen_malloc);
+    const len1 = WASM_VECTOR_LEN;
+    const ret = wasm.solve(mode, limit, ptr0, len0, ptr1, len1, black, threat_limit);
+    let v3;
+    if (ret[0] !== 0) {
+        v3 = getArrayU8FromWasm0(ret[0], ret[1]).slice();
+        wasm.__wbindgen_free(ret[0], ret[1] * 1, 1);
     }
+    return v3;
 }
 
 /**
-* @param {Uint8Array} blacks
-* @param {Uint8Array} whites
-* @param {boolean} black
-* @param {number} limit
-* @returns {Uint8Array | undefined}
-*/
+ * @param {Uint8Array} blacks
+ * @param {Uint8Array} whites
+ * @param {boolean} black
+ * @param {number} limit
+ * @returns {Uint8Array | undefined}
+ */
 export function solve_vcf(blacks, whites, black, limit) {
-    try {
-        const retptr = wasm.__wbindgen_add_to_stack_pointer(-16);
-        const ptr0 = passArray8ToWasm0(blacks, wasm.__wbindgen_malloc);
-        const len0 = WASM_VECTOR_LEN;
-        const ptr1 = passArray8ToWasm0(whites, wasm.__wbindgen_malloc);
-        const len1 = WASM_VECTOR_LEN;
-        wasm.solve_vcf(retptr, ptr0, len0, ptr1, len1, black, limit);
-        var r0 = getInt32Memory0()[retptr / 4 + 0];
-        var r1 = getInt32Memory0()[retptr / 4 + 1];
-        let v3;
-        if (r0 !== 0) {
-            v3 = getArrayU8FromWasm0(r0, r1).slice();
-            wasm.__wbindgen_free(r0, r1 * 1, 1);
-        }
-        return v3;
-    } finally {
-        wasm.__wbindgen_add_to_stack_pointer(16);
+    const ptr0 = passArray8ToWasm0(blacks, wasm.__wbindgen_malloc);
+    const len0 = WASM_VECTOR_LEN;
+    const ptr1 = passArray8ToWasm0(whites, wasm.__wbindgen_malloc);
+    const len1 = WASM_VECTOR_LEN;
+    const ret = wasm.solve_vcf(ptr0, len0, ptr1, len1, black, limit);
+    let v3;
+    if (ret[0] !== 0) {
+        v3 = getArrayU8FromWasm0(ret[0], ret[1]).slice();
+        wasm.__wbindgen_free(ret[0], ret[1] * 1, 1);
     }
+    return v3;
 }
 
 /**
-* @param {Uint8Array} blacks
-* @param {Uint8Array} whites
-* @param {boolean} black
-* @param {number} limit
-* @returns {Uint8Array | undefined}
-*/
+ * @param {Uint8Array} blacks
+ * @param {Uint8Array} whites
+ * @param {boolean} black
+ * @param {number} limit
+ * @returns {Uint8Array | undefined}
+ */
 export function solve_vct(blacks, whites, black, limit) {
-    try {
-        const retptr = wasm.__wbindgen_add_to_stack_pointer(-16);
-        const ptr0 = passArray8ToWasm0(blacks, wasm.__wbindgen_malloc);
-        const len0 = WASM_VECTOR_LEN;
-        const ptr1 = passArray8ToWasm0(whites, wasm.__wbindgen_malloc);
-        const len1 = WASM_VECTOR_LEN;
-        wasm.solve_vct(retptr, ptr0, len0, ptr1, len1, black, limit);
-        var r0 = getInt32Memory0()[retptr / 4 + 0];
-        var r1 = getInt32Memory0()[retptr / 4 + 1];
-        let v3;
-        if (r0 !== 0) {
-            v3 = getArrayU8FromWasm0(r0, r1).slice();
-            wasm.__wbindgen_free(r0, r1 * 1, 1);
-        }
-        return v3;
-    } finally {
-        wasm.__wbindgen_add_to_stack_pointer(16);
+    const ptr0 = passArray8ToWasm0(blacks, wasm.__wbindgen_malloc);
+    const len0 = WASM_VECTOR_LEN;
+    const ptr1 = passArray8ToWasm0(whites, wasm.__wbindgen_malloc);
+    const len1 = WASM_VECTOR_LEN;
+    const ret = wasm.solve_vct(ptr0, len0, ptr1, len1, black, limit);
+    let v3;
+    if (ret[0] !== 0) {
+        v3 = getArrayU8FromWasm0(ret[0], ret[1]).slice();
+        wasm.__wbindgen_free(ret[0], ret[1] * 1, 1);
     }
+    return v3;
 }
 
 /**
-* @param {Uint8Array} blacks
-* @param {Uint8Array} whites
-* @param {boolean} black
-* @param {number} limit
-* @returns {Uint8Array | undefined}
-*/
+ * @param {Uint8Array} blacks
+ * @param {Uint8Array} whites
+ * @param {boolean} black
+ * @param {number} limit
+ * @returns {Uint8Array | undefined}
+ */
 export function solve_vct_dfpn(blacks, whites, black, limit) {
-    try {
-        const retptr = wasm.__wbindgen_add_to_stack_pointer(-16);
-        const ptr0 = passArray8ToWasm0(blacks, wasm.__wbindgen_malloc);
-        const len0 = WASM_VECTOR_LEN;
-        const ptr1 = passArray8ToWasm0(whites, wasm.__wbindgen_malloc);
-        const len1 = WASM_VECTOR_LEN;
-        wasm.solve_vct_dfpn(retptr, ptr0, len0, ptr1, len1, black, limit);
-        var r0 = getInt32Memory0()[retptr / 4 + 0];
-        var r1 = getInt32Memory0()[retptr / 4 + 1];
-        let v3;
-        if (r0 !== 0) {
-            v3 = getArrayU8FromWasm0(r0, r1).slice();
-            wasm.__wbindgen_free(r0, r1 * 1, 1);
-        }
-        return v3;
-    } finally {
-        wasm.__wbindgen_add_to_stack_pointer(16);
+    const ptr0 = passArray8ToWasm0(blacks, wasm.__wbindgen_malloc);
+    const len0 = WASM_VECTOR_LEN;
+    const ptr1 = passArray8ToWasm0(whites, wasm.__wbindgen_malloc);
+    const len1 = WASM_VECTOR_LEN;
+    const ret = wasm.solve_vct_dfpn(ptr0, len0, ptr1, len1, black, limit);
+    let v3;
+    if (ret[0] !== 0) {
+        v3 = getArrayU8FromWasm0(ret[0], ret[1]).slice();
+        wasm.__wbindgen_free(ret[0], ret[1] * 1, 1);
     }
+    return v3;
 }
-
-/**
-* @param {number} x
-* @param {number} y
-* @returns {number}
-*/
-export function encode_xy(x, y) {
-    const ret = wasm.encode_xy(x, y);
-    return ret;
+export function __wbindgen_init_externref_table() {
+    const table = wasm.__wbindgen_externrefs;
+    const offset = table.grow(4);
+    table.set(0, undefined);
+    table.set(offset + 0, undefined);
+    table.set(offset + 1, null);
+    table.set(offset + 2, true);
+    table.set(offset + 3, false);
+}
+function getArrayU8FromWasm0(ptr, len) {
+    ptr = ptr >>> 0;
+    return getUint8ArrayMemory0().subarray(ptr / 1, ptr / 1 + len);
 }
 
-/**
-* @param {number} code
-* @returns {number}
-*/
-export function decode_x(code) {
-    const ret = wasm.decode_x(code);
-    return ret;
+let cachedUint8ArrayMemory0 = null;
+function getUint8ArrayMemory0() {
+    if (cachedUint8ArrayMemory0 === null || cachedUint8ArrayMemory0.byteLength === 0) {
+        cachedUint8ArrayMemory0 = new Uint8Array(wasm.memory.buffer);
+    }
+    return cachedUint8ArrayMemory0;
 }
 
-/**
-* @param {number} code
-* @returns {number}
-*/
-export function decode_y(code) {
-    const ret = wasm.decode_y(code);
-    return ret;
+function passArray8ToWasm0(arg, malloc) {
+    const ptr = malloc(arg.length * 1, 1) >>> 0;
+    getUint8ArrayMemory0().set(arg, ptr / 1);
+    WASM_VECTOR_LEN = arg.length;
+    return ptr;
 }
 
+let WASM_VECTOR_LEN = 0;
+
+
+let wasm;
+export function __wbg_set_wasm(val) {
+    wasm = val;
+}