@woosh/meep-engine 3.28.0 → 3.30.0

package/src/core/wfc/wfc_state_ban_bits.js

@@ -0,0 +1,81 @@
+import { ctz32 } from "../binary/ctz32.js";
+
+/**
+ * Remove a set of tiles from one word of one cell's domain.
+ *
+ * Every domain shrink goes through here: it moves the wave, the undo trail, the possibility count,
+ * both weight accumulators and the cell's queue membership together, and applying a shrink any
+ * other way desynchronises them.
+ *
+ * An emptied domain is reported on `state.contradiction` rather than returned, so the propagator
+ * checks it once per relaxation instead of once per call.
+ *
+ * @param {WFCState} state
+ * @param {number} cell
+ * @param {number} word_index which word of the cell's domain, in `[0, words_per_cell)`
+ * @param {number} bits tiles to remove; bits already clear are ignored
+ */
+export function wfc_state_ban_bits(state, cell, word_index, bits) {
+    const wave = state.wave;
+    const address = cell * state.words_per_cell + word_index;
+    const current = wave[address];
+    const removed = current & bits;
+
+    if (removed === 0) {
+        return;
+    }
+
+    wave[address] = current & ~removed;
+
+    state.trail_push(address, removed);
+
+    const weight = state.weights.weight;
+    const weight_log_weight = state.weights.weight_log_weight;
+    const tile_base = word_index << 5;
+
+    let weight_delta = 0;
+    let weight_log_delta = 0;
+    let count = 0;
+    let rest = removed;
+
+    // one pass: count the bits and accumulate their weights together, rather than a bitCount()
+    // call followed by a second walk over the same word
+    while (rest !== 0) {
+        const low = rest & -rest;
+        const tile = tile_base + ctz32(low);
+
+        rest ^= low;
+        count++;
+
+        weight_delta += weight[tile];
+        weight_log_delta += weight_log_weight[tile];
+    }
+
+    const old_count = state.possibility_count[cell];
+    const new_count = old_count - count;
+
+    state.possibility_count[cell] = new_count;
+    state.weight_sum[cell] -= weight_delta;
+    state.weight_log_sum[cell] -= weight_log_delta;
+
+    if (old_count > 1 && new_count <= 1 && state.eligible[cell] === 1) {
+        state.undecided_eligible--;
+    }
+
+    // marked and queued even when the domain just emptied. The backtracker restores this cell like
+    // any other and needs its heap entry rescored on the way back up; leaving one cell out of the
+    // bookkeeping because it happened to be the one that failed is how that goes wrong.
+    if (state.dirty[cell] === 0) {
+        state.dirty[cell] = 1;
+        state.dirty_list[state.dirty_count++] = cell;
+    }
+
+    if (state.in_queue[cell] === 0) {
+        state.in_queue[cell] = 1;
+        state.queue[state.queue_count++] = cell;
+    }
+
+    if (new_count === 0) {
+        state.contradiction = true;
+    }
+}

package/src/core/wfc/wfc_state_collapse.d.ts

@@ -0,0 +1,12 @@
+/**
+ * Choose one tile for `cell`, weighted by the tile weights, and ban the rest.
+ *
+ * Consumes the RNG exactly once. The weight sum is recomputed here rather than read from
+ * `state.weight_sum`, which drifts.
+ *
+ * @param {WFCState} state
+ * @param {number} cell must hold at least one possibility
+ * @returns {number} the tile chosen
+ */
+export function wfc_state_collapse(state: WFCState, cell: number): number;
+//# sourceMappingURL=wfc_state_collapse.d.ts.map

package/src/core/wfc/wfc_state_collapse.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"wfc_state_collapse.d.ts","sourceRoot":"","sources":["../../../../src/core/wfc/wfc_state_collapse.js"],"names":[],"mappings":"AAGA;;;;;;;;;GASG;AACH,0DAHW,MAAM,GACJ,MAAM,CA6DlB"}

package/src/core/wfc/wfc_state_collapse.js

@@ -0,0 +1,73 @@
+import { ctz32 } from "../binary/ctz32.js";
+import { wfc_state_ban_bits } from "./wfc_state_ban_bits.js";
+
+/**
+ * Choose one tile for `cell`, weighted by the tile weights, and ban the rest.
+ *
+ * Consumes the RNG exactly once. The weight sum is recomputed here rather than read from
+ * `state.weight_sum`, which drifts.
+ *
+ * @param {WFCState} state
+ * @param {number} cell must hold at least one possibility
+ * @returns {number} the tile chosen
+ */
+export function wfc_state_collapse(state, cell) {
+    const { wave, words_per_cell } = state;
+    const weight = state.weights.weight;
+    const base = cell * words_per_cell;
+
+    let total = 0;
+
+    for (let w = 0; w < words_per_cell; w++) {
+        let word = wave[base + w];
+        const tile_base = w << 5;
+
+        while (word !== 0) {
+            const low = word & -word;
+
+            word ^= low;
+            total += weight[tile_base + ctz32(low)];
+        }
+    }
+
+    let remaining = state.random() * total;
+    let chosen = -1;
+
+    pick: for (let w = 0; w < words_per_cell; w++) {
+        let word = wave[base + w];
+        const tile_base = w << 5;
+
+        while (word !== 0) {
+            const low = word & -word;
+
+            word ^= low;
+
+            const tile = tile_base + ctz32(low);
+
+            chosen = tile;
+            remaining -= weight[tile];
+
+            if (remaining < 0) {
+                break pick;
+            }
+        }
+    }
+
+    // `chosen` is the last tile visited whenever the subtraction never went negative, which the
+    // identical summation order makes unreachable in exact arithmetic and leaves harmless if a
+    // future change breaks that: the fallback is a legal tile, not an out-of-range index.
+    const chosen_word = chosen >> 5;
+    const chosen_bit = 1 << (chosen & 31);
+
+    for (let w = 0; w < words_per_cell; w++) {
+        const removable = w === chosen_word
+            ? (wave[base + w] & ~chosen_bit)
+            : wave[base + w];
+
+        if (removable !== 0) {
+            wfc_state_ban_bits(state, cell, w, removable);
+        }
+    }
+
+    return chosen;
+}

package/src/core/wfc/wfc_state_flush_dirty.d.ts

@@ -0,0 +1,12 @@
+/**
+ * Bring the selection queue back in step with the wave, one operation per changed cell rather than
+ * one per banned tile.
+ *
+ * A cell down to a single possibility has no decision left in it and leaves the queue.
+ *
+ * A no-op under {@link WFCCellChoice.SCANLINE}, which keeps no queue.
+ *
+ * @param {WFCState} state
+ */
+export function wfc_state_flush_dirty(state: WFCState): void;
+//# sourceMappingURL=wfc_state_flush_dirty.d.ts.map

package/src/core/wfc/wfc_state_flush_dirty.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"wfc_state_flush_dirty.d.ts","sourceRoot":"","sources":["../../../../src/core/wfc/wfc_state_flush_dirty.js"],"names":[],"mappings":"AAAA;;;;;;;;;GASG;AACH,6DA4BC"}

package/src/core/wfc/wfc_state_flush_dirty.js

@@ -0,0 +1,39 @@
+/**
+ * Bring the selection queue back in step with the wave, one operation per changed cell rather than
+ * one per banned tile.
+ *
+ * A cell down to a single possibility has no decision left in it and leaves the queue.
+ *
+ * A no-op under {@link WFCCellChoice.SCANLINE}, which keeps no queue.
+ *
+ * @param {WFCState} state
+ */
+export function wfc_state_flush_dirty(state) {
+    const { dirty, dirty_list, possibility_count, eligible, heap } = state;
+    const count = state.dirty_count;
+
+    for (let i = 0; i < count; i++) {
+        const cell = dirty_list[i];
+
+        dirty[cell] = 0;
+
+        if (heap === null) {
+            continue;
+        }
+
+        const present = heap.contains(cell);
+        const wanted = eligible[cell] === 1 && possibility_count[cell] > 1;
+
+        if (wanted) {
+            if (present) {
+                heap.update(cell, state.score_of(cell));
+            } else {
+                heap.insert(cell, state.score_of(cell));
+            }
+        } else if (present) {
+            heap.remove(cell);
+        }
+    }
+
+    state.dirty_count = 0;
+}

package/src/core/wfc/wfc_state_propagate.d.ts

@@ -0,0 +1,14 @@
+/**
+ * Arc consistency over the propagation queue: drain it, relaxing every queued cell against each of
+ * its neighbours, until nothing more can be removed.
+ *
+ * Returns when the queue empties, when a domain empties (`state.contradiction`), or when the
+ * budget runs out — in which case the queue is left as it stands and a later call continues from
+ * it.
+ *
+ * @param {WFCState} state
+ * @param {number} budget relaxations this call may perform
+ * @returns {number} relaxations actually performed
+ */
+export function wfc_state_propagate(state: WFCState, budget: number): number;
+//# sourceMappingURL=wfc_state_propagate.d.ts.map

package/src/core/wfc/wfc_state_propagate.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"wfc_state_propagate.d.ts","sourceRoot":"","sources":["../../../../src/core/wfc/wfc_state_propagate.js"],"names":[],"mappings":"AAGA;;;;;;;;;;;GAWG;AACH,6DAHW,MAAM,GACJ,MAAM,CA6IlB"}

package/src/core/wfc/wfc_state_propagate.js

@@ -0,0 +1,155 @@
+import { ctz32 } from "../binary/ctz32.js";
+import { wfc_state_ban_bits } from "./wfc_state_ban_bits.js";
+
+/**
+ * Arc consistency over the propagation queue: drain it, relaxing every queued cell against each of
+ * its neighbours, until nothing more can be removed.
+ *
+ * Returns when the queue empties, when a domain empties (`state.contradiction`), or when the
+ * budget runs out — in which case the queue is left as it stands and a later call continues from
+ * it.
+ *
+ * @param {WFCState} state
+ * @param {number} budget relaxations this call may perform
+ * @returns {number} relaxations actually performed
+ */
+export function wfc_state_propagate(state, budget) {
+    const {
+        wave,
+        queue,
+        in_queue,
+        possibility_count,
+        words_per_cell,
+        direction_count,
+        tile_count,
+        uncovered
+    } = state;
+
+    const lattice = state.lattice;
+    const edge_flags = lattice.edge_flags;
+    const wrap = lattice.wrap;
+    const neighbour_offsets = lattice.neighbour_offsets;
+    const wrap_offsets = lattice.wrap_offsets;
+
+    const rule_data = state.rules.data;
+    const full_support = state.rules.full_support;
+
+    let spent = 0;
+
+    while (state.queue_count > 0) {
+        if (spent >= budget) {
+            return spent;
+        }
+
+        // drained LIFO rather than FIFO: any order reaches the same fixpoint, and a stack keeps
+        // the frontier local, so consecutive relaxations tend to touch neighbouring cells
+        const cell = queue[--state.queue_count];
+
+        in_queue[cell] = 0;
+
+        if (possibility_count[cell] === 0) {
+            // a cell that emptied; the caller is about to backtrack
+            state.contradiction = true;
+            return spent;
+        }
+
+        const flags = edge_flags[cell];
+        const source_base = cell * words_per_cell;
+
+        for (let d = 0; d < direction_count; d++) {
+            let target;
+
+            if (((flags >> d) & 1) === 1) {
+                if (wrap[d >> 1] === 0) {
+                    continue;
+                }
+
+                target = cell + wrap_offsets[d];
+            } else {
+                target = cell + neighbour_offsets[d];
+            }
+
+            spent++;
+
+            const target_base = target * words_per_cell;
+
+            // re-read rather than hoist: on a one-cell wrapping axis a cell is its own neighbour,
+            // so a ban in an earlier direction can have shrunk the source we are about to read
+            if (possibility_count[cell] === tile_count) {
+                // Fast path: a source that has lost nothing supports exactly the precomputed union
+                // of every tile's row, so this costs O(words_per_cell) instead of a scan over the
+                // whole domain. A cell stops being pristine the moment anything is removed from
+                // it, so in practice this is close to the initial sweep and little else - it keeps
+                // the opening linear in the tile count rather than carrying the whole solve.
+                const support_base = d * words_per_cell;
+
+                for (let w = 0; w < words_per_cell; w++) {
+                    const removable = wave[target_base + w] & ~full_support[support_base + w];
+
+                    if (removable !== 0) {
+                        wfc_state_ban_bits(state, target, w, removable);
+                    }
+                }
+            } else {
+                // General path, written around what is still UNSUPPORTED rather than around an
+                // accumulated "allowed" mask: same result, one fewer buffer, and the early-out
+                // falls out of the loop naturally.
+                let any = 0;
+
+                for (let w = 0; w < words_per_cell; w++) {
+                    const u = wave[target_base + w];
+
+                    uncovered[w] = u;
+                    any |= u;
+                }
+
+                if (any === 0) {
+                    state.contradiction = true;
+                    return spent;
+                }
+
+                const direction_base = d * tile_count * words_per_cell;
+
+                scan: for (let sw = 0; sw < words_per_cell; sw++) {
+                    let word = wave[source_base + sw];
+
+                    while (word !== 0) {
+                        const low = word & -word;
+
+                        word ^= low;
+
+                        const row = direction_base + ((sw << 5) + ctz32(low)) * words_per_cell;
+
+                        let left = 0;
+
+                        for (let w = 0; w < words_per_cell; w++) {
+                            const u = uncovered[w] & ~rule_data[row + w];
+
+                            uncovered[w] = u;
+                            left |= u;
+                        }
+
+                        if (left === 0) {
+                            // everything the target still holds has support; nothing to remove
+                            break scan;
+                        }
+                    }
+                }
+
+                for (let w = 0; w < words_per_cell; w++) {
+                    const removable = uncovered[w];
+
+                    if (removable !== 0) {
+                        wfc_state_ban_bits(state, target, w, removable);
+                    }
+                }
+            }
+
+            if (state.contradiction) {
+                return spent;
+            }
+        }
+    }
+
+    return spent;
+}

package/src/core/wfc/wfc_state_read.d.ts

@@ -0,0 +1,11 @@
+/**
+ * Write the chosen tile of every cell into `out`.
+ *
+ * A cell not down to a single possibility reads {@link WFC_UNRESOLVED} — either the solve has not
+ * finished, or the cell was never eligible to be collapsed.
+ *
+ * @param {Uint32Array|number[]} out at least `cell_count` long
+ * @param {WFCState} state
+ */
+export function wfc_state_read(out: Uint32Array | number[], state: WFCState): void;
+//# sourceMappingURL=wfc_state_read.d.ts.map

package/src/core/wfc/wfc_state_read.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"wfc_state_read.d.ts","sourceRoot":"","sources":["../../../../src/core/wfc/wfc_state_read.js"],"names":[],"mappings":"AAIA;;;;;;;;GAQG;AACH,oCAHW,WAAW,GAAC,MAAM,EAAE,yBA2B9B"}

package/src/core/wfc/wfc_state_read.js

@@ -0,0 +1,38 @@
+import { assert } from "../assert.js";
+import { ctz32 } from "../binary/ctz32.js";
+import { WFC_UNRESOLVED } from "./WFC_UNRESOLVED.js";
+
+/**
+ * Write the chosen tile of every cell into `out`.
+ *
+ * A cell not down to a single possibility reads {@link WFC_UNRESOLVED} — either the solve has not
+ * finished, or the cell was never eligible to be collapsed.
+ *
+ * @param {Uint32Array|number[]} out at least `cell_count` long
+ * @param {WFCState} state
+ */
+export function wfc_state_read(out, state) {
+    assert.defined(state, 'state');
+    assert.isArrayLike(out, 'out');
+    assert.greaterThanOrEqual(out.length, state.cell_count, 'out.length >= cell_count');
+
+    const { wave, words_per_cell, possibility_count, cell_count } = state;
+
+    for (let cell = 0; cell < cell_count; cell++) {
+        if (possibility_count[cell] !== 1) {
+            out[cell] = WFC_UNRESOLVED;
+            continue;
+        }
+
+        const base = cell * words_per_cell;
+
+        for (let w = 0; w < words_per_cell; w++) {
+            const word = wave[base + w];
+
+            if (word !== 0) {
+                out[cell] = (w << 5) + ctz32(word);
+                break;
+            }
+        }
+    }
+}

package/src/core/wfc/wfc_state_restrict.d.ts

@@ -0,0 +1,18 @@
+/**
+ * Narrow a cell's domain to the tiles named by `mask_words` — the partial grid a caller supplies
+ * before solving.
+ *
+ * Restrictions compose: applying two leaves the intersection. The cell is queued, so the next
+ * {@link wfc_solve} call propagates the consequences.
+ *
+ * Apply before the first solve call if the restriction is meant to be permanent. One applied
+ * mid-solve goes onto the undo trail like any other narrowing, so a backtrack past it restores the
+ * tiles.
+ *
+ * @param {WFCState} state
+ * @param {number} cell
+ * @param {Uint32Array|number[]} mask_words `words_per_cell` words; bit `t` set keeps tile `t`
+ * @returns {boolean} false when the restriction emptied the cell
+ */
+export function wfc_state_restrict(state: WFCState, cell: number, mask_words: Uint32Array | number[]): boolean;
+//# sourceMappingURL=wfc_state_restrict.d.ts.map

package/src/core/wfc/wfc_state_restrict.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"wfc_state_restrict.d.ts","sourceRoot":"","sources":["../../../../src/core/wfc/wfc_state_restrict.js"],"names":[],"mappings":"AAGA;;;;;;;;;;;;;;;GAeG;AACH,0DAJW,MAAM,cACN,WAAW,GAAC,MAAM,EAAE,GAClB,OAAO,CAqBnB"}

package/src/core/wfc/wfc_state_restrict.js

@@ -0,0 +1,39 @@
+import { assert } from "../assert.js";
+import { wfc_state_ban_bits } from "./wfc_state_ban_bits.js";
+
+/**
+ * Narrow a cell's domain to the tiles named by `mask_words` — the partial grid a caller supplies
+ * before solving.
+ *
+ * Restrictions compose: applying two leaves the intersection. The cell is queued, so the next
+ * {@link wfc_solve} call propagates the consequences.
+ *
+ * Apply before the first solve call if the restriction is meant to be permanent. One applied
+ * mid-solve goes onto the undo trail like any other narrowing, so a backtrack past it restores the
+ * tiles.
+ *
+ * @param {WFCState} state
+ * @param {number} cell
+ * @param {Uint32Array|number[]} mask_words `words_per_cell` words; bit `t` set keeps tile `t`
+ * @returns {boolean} false when the restriction emptied the cell
+ */
+export function wfc_state_restrict(state, cell, mask_words) {
+    assert.defined(state, 'state');
+    assert.isArrayLike(mask_words, 'mask_words');
+    assert.isNonNegativeInteger(cell, 'cell');
+    assert.lessThan(cell, state.cell_count, 'cell < cell_count');
+    assert.greaterThanOrEqual(mask_words.length, state.words_per_cell, 'mask_words.length >= words_per_cell');
+
+    const { wave, words_per_cell } = state;
+    const base = cell * words_per_cell;
+
+    for (let w = 0; w < words_per_cell; w++) {
+        const removable = wave[base + w] & ~mask_words[w];
+
+        if (removable !== 0) {
+            wfc_state_ban_bits(state, cell, w, removable);
+        }
+    }
+
+    return !state.contradiction;
+}

package/src/core/wfc/wfc_state_set_eligible.d.ts

@@ -0,0 +1,24 @@
+/**
+ * Restrict the solver to collapsing only the listed cells. Everything outside the set keeps its
+ * domain and still constrains its neighbours through propagation; it is simply never chosen.
+ *
+ * This is the primitive the block-based generation methods are built on:
+ *
+ *  - *block solve* — restore a block's domains, mark only those cells eligible, solve;
+ *  - *erosion on failure* — on {@link WFCStatus.UNSATISFIABLE}, widen the block into resolved
+ *    territory and retry;
+ *  - *streaming* — slide the eligible window across a lattice larger than any one solve.
+ *
+ * **Everything already decided becomes permanent.** The decision stack and the undo trail are
+ * dropped (see {@link WFCState#commit}), so the search cannot reach back past this point. Without
+ * that, a block that turns out to be unsatisfiable would backtrack into the previous one,
+ * un-decide cells that are no longer selectable, and report success with a hole in the result.
+ *
+ * Rebuilds the selection queue, so call it before stepping rather than between propagation waves.
+ * Solving in blocks is slower than solving a grid whole; it is for failure containment, not speed.
+ *
+ * @param {WFCState} state
+ * @param {Uint32Array|number[]} cells cell indices that may be collapsed; must not repeat one
+ */
+export function wfc_state_set_eligible(state: WFCState, cells: Uint32Array | number[]): void;
+//# sourceMappingURL=wfc_state_set_eligible.d.ts.map

package/src/core/wfc/wfc_state_set_eligible.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"wfc_state_set_eligible.d.ts","sourceRoot":"","sources":["../../../../src/core/wfc/wfc_state_set_eligible.js"],"names":[],"mappings":"AAEA;;;;;;;;;;;;;;;;;;;;;GAqBG;AACH,+DAFW,WAAW,GAAC,MAAM,EAAE,QA0B9B"}

package/src/core/wfc/wfc_state_set_eligible.js

@@ -0,0 +1,49 @@
+import { assert } from "../assert.js";
+
+/**
+ * Restrict the solver to collapsing only the listed cells. Everything outside the set keeps its
+ * domain and still constrains its neighbours through propagation; it is simply never chosen.
+ *
+ * This is the primitive the block-based generation methods are built on:
+ *
+ *  - *block solve* — restore a block's domains, mark only those cells eligible, solve;
+ *  - *erosion on failure* — on {@link WFCStatus.UNSATISFIABLE}, widen the block into resolved
+ *    territory and retry;
+ *  - *streaming* — slide the eligible window across a lattice larger than any one solve.
+ *
+ * **Everything already decided becomes permanent.** The decision stack and the undo trail are
+ * dropped (see {@link WFCState#commit}), so the search cannot reach back past this point. Without
+ * that, a block that turns out to be unsatisfiable would backtrack into the previous one,
+ * un-decide cells that are no longer selectable, and report success with a hole in the result.
+ *
+ * Rebuilds the selection queue, so call it before stepping rather than between propagation waves.
+ * Solving in blocks is slower than solving a grid whole; it is for failure containment, not speed.
+ *
+ * @param {WFCState} state
+ * @param {Uint32Array|number[]} cells cell indices that may be collapsed; must not repeat one
+ */
+export function wfc_state_set_eligible(state, cells) {
+    assert.defined(state, 'state');
+    assert.isArrayLike(cells, 'cells');
+
+    state.commit();
+
+    state.eligible.fill(0);
+
+    for (let i = 0; i < cells.length; i++) {
+        const cell = cells[i];
+
+        assert.isNonNegativeInteger(cell, 'cells[i]');
+        assert.lessThan(cell, state.cell_count, 'cells[i] < cell_count');
+        // the flags were just cleared, so a set flag here means this cell appears twice. A repeat
+        // would be counted twice as undecided and the solve would then run out of cells to collapse
+        // before the count reached zero.
+        assert.equal(state.eligible[cell], 0, 'cells must not contain duplicates');
+
+        state.eligible[cell] = 1;
+    }
+
+    // hand the list on rather than making the rebuild scan the whole grid: block solving calls
+    // this once per block, and that scan is what made solving in blocks slower than solving whole
+    state.reseed_selection(cells);
+}

package/src/core/wfc/wfc_state_undo_to.d.ts

@@ -0,0 +1,13 @@
+/**
+ * Rewind the wave, and everything derived from it, to a trail mark — the exact mirror of
+ * {@link wfc_state_ban_bits}.
+ *
+ * Cells touched are marked dirty so {@link wfc_state_flush_dirty} can repair the selection queue
+ * afterwards. The propagation queue is emptied rather than rewound: its contents were derived from
+ * a wave that no longer exists.
+ *
+ * @param {WFCState} state
+ * @param {number} trail_mark trail length to return to
+ */
+export function wfc_state_undo_to(state: WFCState, trail_mark: number): void;
+//# sourceMappingURL=wfc_state_undo_to.d.ts.map

package/src/core/wfc/wfc_state_undo_to.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"wfc_state_undo_to.d.ts","sourceRoot":"","sources":["../../../../src/core/wfc/wfc_state_undo_to.js"],"names":[],"mappings":"AAEA;;;;;;;;;;GAUG;AACH,+DAFW,MAAM,QAwEhB"}