cubing 0.28.1 → 0.28.2

package/dist/esm/{search-dynamic-solve-fto-O6UXF7EC.js → search-dynamic-solve-fto-4LI23P6K.js}

@@ -1,7 +1,7 @@
 import {
   randomUIntBelowFactory
-} from "./chunk-V55YSWJY.js";
-import "./chunk-MGJA5U5O.js";
+} from "./chunk-WXCNEGW3.js";
+import "./chunk-SBZRVSPK.js";
 
 // src/cubing/vendor/xyzzy/fto-solver.js
 function factorial(n) {
@@ -296,17 +296,20 @@ function permutation_order(perm) {
   return order;
 }
 var solved_state = Array(72).fill().map((_, i) => i / 9 | 0);
-var move_U = permutation_from_cycles([
-  [0, 4, 8],
-  [1, 6, 3],
-  [2, 5, 7],
-  [9, 22, 35],
-  [45, 67, 44],
-  [47, 68, 43],
-  [46, 69, 39],
-  [50, 70, 38],
-  [49, 71, 36]
-], 72);
+var move_U = permutation_from_cycles(
+  [
+    [0, 4, 8],
+    [1, 6, 3],
+    [2, 5, 7],
+    [9, 22, 35],
+    [45, 67, 44],
+    [47, 68, 43],
+    [46, 69, 39],
+    [50, 70, 38],
+    [49, 71, 36]
+  ],
+  72
+);
 var move_Ui = compose(move_U, move_U);
 var move_X = Array(72).fill().map((_, i) => (i / 18 | 0) * 18 + (i + 9) % 18);
 var move_Y = Array(72).fill().map((_, i) => (i / 36 | 0) * 36 + (i + 18) % 36);
@@ -314,14 +317,17 @@ var move_Z = Array(72).fill().map((_, i) => (i + 36) % 72);
 var move_L = compose3(move_Z, move_Ui, move_Z);
 var move_F = compose3(move_X, move_U, move_X);
 var move_R = compose3(move_X, move_L, move_X);
-var move_Us = permutation_from_cycles([
-  [10, 24, 30],
-  [11, 23, 34],
-  [12, 19, 33],
-  [42, 48, 64],
-  [41, 52, 65],
-  [37, 51, 66]
-], 72);
+var move_Us = permutation_from_cycles(
+  [
+    [10, 24, 30],
+    [11, 23, 34],
+    [12, 19, 33],
+    [42, 48, 64],
+    [41, 52, 65],
+    [37, 51, 66]
+  ],
+  72
+);
 var move_Uw = compose(move_U, move_Us);
 var move_Uwi = compose(move_Uw, move_Uw);
 var move_Lw = compose3(move_Z, move_Uwi, move_Z);
@@ -374,10 +380,16 @@ function identify_edge_piece(colourA, colourB) {
   throw new Error("unknown edge piece");
 }
 function get_corner_piece(facelets, location) {
-  return identify_corner_piece(facelets[corner_piece_facelets[location][0]], facelets[corner_piece_facelets[location][2]]);
+  return identify_corner_piece(
+    facelets[corner_piece_facelets[location][0]],
+    facelets[corner_piece_facelets[location][2]]
+  );
 }
 function get_edge_piece(facelets, location) {
-  return identify_edge_piece(facelets[edge_piece_facelets[location][0]], facelets[edge_piece_facelets[location][1]]);
+  return identify_edge_piece(
+    facelets[edge_piece_facelets[location][0]],
+    facelets[edge_piece_facelets[location][1]]
+  );
 }
 function set_corner_piece(facelets, location, value, orientation) {
   let indices = corner_piece_facelets[location];
@@ -402,8 +414,12 @@ function convert_move_to_permutations(move) {
   let cp_half = cp_raw.map(([p, o]) => p + 6 * o);
   let cp = cp_half.concat(cp_half.map((x) => (x + 6) % 12));
   let ep = Array(12).fill().map((_, i) => get_edge_piece(state, i));
-  let ap = Array(12).fill().map((_, i) => centreA_piece_facelets.indexOf(move[centreA_piece_facelets[i]]));
-  let bp = Array(12).fill().map((_, i) => centreB_piece_facelets.indexOf(move[centreB_piece_facelets[i]]));
+  let ap = Array(12).fill().map(
+    (_, i) => centreA_piece_facelets.indexOf(move[centreA_piece_facelets[i]])
+  );
+  let bp = Array(12).fill().map(
+    (_, i) => centreB_piece_facelets.indexOf(move[centreB_piece_facelets[i]])
+  );
   return { cp, ep, ap, bp };
 }
 var moves = [
@@ -510,7 +526,10 @@ function simplify_move_sequence(move_sequence, make_noise = false) {
   return simplified;
 }
 function generate_random_state_scramble(randomUintBelow2) {
-  return stringify_move_sequence(invert_move_sequence(solve(random_state(randomUintBelow2), true)), true);
+  return stringify_move_sequence(
+    invert_move_sequence(solve(random_state(randomUintBelow2), true)),
+    true
+  );
 }
 function generate_mtable_comb4_generic(n, k0, k1, k2, k3, permutations) {
   let N = C4(n, k0, k1, k2, k3);
@@ -704,10 +723,14 @@ function index_phase1(facelets) {
   let [itc, cti] = generate_comb4_lookup_tables(12, 6, 0, 3, 3);
   let ep = Array(12).fill().map((_, i) => get_edge_piece(facelets, i));
   let edge_coord = ep.indexOf(8) + 12 * ep.indexOf(9) + 12 ** 2 * ep.indexOf(10) + 12 ** 3 * ep.indexOf(11);
-  let [a_coord, b_coord] = [centreA_piece_facelets, centreB_piece_facelets].map((facelet_indices) => {
-    let arr = facelet_indices.map((x) => phase1_centre_colour_map[facelets[x]]);
-    return cti[arr.reduce((acc, x, j) => acc | x << 2 * j, 0)];
-  });
+  let [a_coord, b_coord] = [centreA_piece_facelets, centreB_piece_facelets].map(
+    (facelet_indices) => {
+      let arr = facelet_indices.map(
+        (x) => phase1_centre_colour_map[facelets[x]]
+      );
+      return cti[arr.reduce((acc, x, j) => acc | x << 2 * j, 0)];
+    }
+  );
   return [edge_coord, a_coord, b_coord];
 }
 function generate_phase1_edge_mtable() {
@@ -731,13 +754,27 @@ function generate_phase1_centreA_mtable() {
   if (cached_mtables.phase1_centreA) {
     return cached_mtables.phase1_centreA;
   }
-  return cached_mtables.phase1_centreA = generate_mtable_comb4_generic(12, 6, 0, 3, 3, move_permutations.map((x) => x.ap));
+  return cached_mtables.phase1_centreA = generate_mtable_comb4_generic(
+    12,
+    6,
+    0,
+    3,
+    3,
+    move_permutations.map((x) => x.ap)
+  );
 }
 function generate_phase1_centreB_mtable() {
   if (cached_mtables.phase1_centreB) {
     return cached_mtables.phase1_centreB;
   }
-  return cached_mtables.phase1_centreB = generate_mtable_comb4_generic(12, 6, 0, 3, 3, move_permutations.map((x) => x.bp));
+  return cached_mtables.phase1_centreB = generate_mtable_comb4_generic(
+    12,
+    6,
+    0,
+    3,
+    3,
+    move_permutations.map((x) => x.bp)
+  );
 }
 function generate_phase1_centre_ptable() {
   if (cached_ptables.phase1_centre) {
@@ -749,7 +786,10 @@ function generate_phase1_centre_ptable() {
     let x9 = x >> 18 & 3;
     return x6 === 2 && x9 === 3;
   }).map((x) => cti[x]);
-  return cached_ptables.phase1_centre = bfs(generate_phase1_centreB_mtable(), goal_states);
+  return cached_ptables.phase1_centre = bfs(
+    generate_phase1_centreB_mtable(),
+    goal_states
+  );
 }
 function* solve_phase1_gen(facelets) {
   let mtables = [
@@ -777,7 +817,11 @@ function* phase1_ida_solve_gen(indices, mtables, ptables, moves_left) {
 function* phase1_ida_search_gen(indices, mtables, ptables, bound, last) {
   let ncoords = 3;
   let nmoves = 8;
-  let heuristic = Math.max(ptables[0][indices[0]], ptables[1][indices[1]], ptables[2][indices[2]]);
+  let heuristic = Math.max(
+    ptables[0][indices[0]],
+    ptables[1][indices[1]],
+    ptables[2][indices[2]]
+  );
   if (heuristic > bound)
     return;
   if (bound === 0) {
@@ -797,7 +841,13 @@ function* phase1_ida_search_gen(indices, mtables, ptables, bound, last) {
     new_indices[2] = mtables[2][m][indices[2]];
     let r = 1;
     while (indices.some((_, i) => indices[i] != new_indices[i])) {
-      let subpath_gen = phase1_ida_search_gen(new_indices, mtables, ptables, bound - 1, m);
+      let subpath_gen = phase1_ida_search_gen(
+        new_indices,
+        mtables,
+        ptables,
+        bound - 1,
+        m
+      );
       while (true) {
         let { value: subpath, done } = subpath_gen.next();
         if (done)
@@ -832,14 +882,20 @@ function index_phase2(facelets) {
   let ep = Array(8).fill().map((_, i) => get_edge_piece(facelets, i));
   let edge_coord = ep.indexOf(5) + 8 * ep.indexOf(6) + 8 ** 2 * ep.indexOf(7);
   let corners = Array(5).fill().map((_, i) => get_corner_piece(facelets, i));
-  let cp_inverse_full = invert_permutation(corners.map(([p, o]) => p + 5 * o).concat(corners.map(([p, o]) => p + 5 * (o ^ 1))));
+  let cp_inverse_full = invert_permutation(
+    corners.map(([p, o]) => p + 5 * o).concat(corners.map(([p, o]) => p + 5 * (o ^ 1)))
+  );
   let cp_inverse = cp_inverse_full.slice(0, 5).map((x) => x % 5);
   let co_inverse = cp_inverse_full.slice(0, 5).map((x) => x / 5 | 0);
   let corner_coord = evenpermutation_to_index(cp_inverse) * 8 + (co_inverse[0] ^ co_inverse[2]) + 2 * (co_inverse[0] ^ co_inverse[3]) + 4 * co_inverse[4];
-  let [a_coord, b_coord] = [centreA_piece_facelets, centreB_piece_facelets].map((facelet_indices) => {
-    let arr = compose(facelet_indices, phase2_centre_indices).map((x) => phase2_centre_colour_map[facelets[x]]);
-    return cti[arr.reduce((acc, x, j) => acc | x << 2 * j, 0)];
-  });
+  let [a_coord, b_coord] = [centreA_piece_facelets, centreB_piece_facelets].map(
+    (facelet_indices) => {
+      let arr = compose(facelet_indices, phase2_centre_indices).map(
+        (x) => phase2_centre_colour_map[facelets[x]]
+      );
+      return cti[arr.reduce((acc, x, j) => acc | x << 2 * j, 0)];
+    }
+  );
   generate_phase2_edge_mtable();
   generate_phase2_corner_mtable_compact();
   return [
@@ -855,8 +911,22 @@ function generate_phase2_centre_mtables() {
   if (cached_mtables.phase2_centre) {
     return cached_mtables.phase2_centre;
   }
-  let a = generate_mtable_comb4_generic(10, 5, 3, 2, 0, move_permutations.slice(0, 4).map((x) => reduce_permutation(x.ap, phase2_keep)));
-  let b = generate_mtable_comb4_generic(10, 5, 3, 2, 0, move_permutations.slice(0, 4).map((x) => reduce_permutation(x.bp, phase2_keep)));
+  let a = generate_mtable_comb4_generic(
+    10,
+    5,
+    3,
+    2,
+    0,
+    move_permutations.slice(0, 4).map((x) => reduce_permutation(x.ap, phase2_keep))
+  );
+  let b = generate_mtable_comb4_generic(
+    10,
+    5,
+    3,
+    2,
+    0,
+    move_permutations.slice(0, 4).map((x) => reduce_permutation(x.bp, phase2_keep))
+  );
   return cached_mtables.phase2_centre = [a, b];
 }
 var phase2_edge_reduction_map;
@@ -864,7 +934,9 @@ function generate_phase2_edge_mtable() {
   if (cached_mtables.phase2_edge) {
     return cached_mtables.phase2_edge;
   }
-  let e = generate_mtable_single_generic(move_permutations.slice(0, 4).map((x) => x.ep.slice(0, 8)));
+  let e = generate_mtable_single_generic(
+    move_permutations.slice(0, 4).map((x) => x.ep.slice(0, 8))
+  );
   let eee = combine_mtables(e, combine_mtables(e, e));
   let eee_trimmed;
   [eee_trimmed, phase2_edge_reduction_map] = trim_unreachable(eee, 501);
@@ -916,7 +988,10 @@ function generate_phase2_corner_mtable_compact() {
   if (cached_mtables.phase2_corner_compact) {
     return cached_mtables.phase2_corner_compact;
   }
-  [cached_mtables.phase2_corner_compact, phase2_corner_reduction_map] = reduce_to_quotient(generate_phase2_corner_mtable(), phase2_corner_goal_states());
+  [cached_mtables.phase2_corner_compact, phase2_corner_reduction_map] = reduce_to_quotient(
+    generate_phase2_corner_mtable(),
+    phase2_corner_goal_states()
+  );
   return cached_mtables.phase2_corner_compact;
 }
 function generate_phase2_ce_mtable() {
@@ -933,7 +1008,11 @@ function generate_phase2_ce_mirror_map() {
     return phase2_ce_mirror_map;
   }
   const ce_solved = index_phase2(solved_state)[2];
-  return phase2_ce_mirror_map = generate_mirrored_coordinate_table(generate_phase2_ce_mtable(), ce_solved, ce_solved);
+  return phase2_ce_mirror_map = generate_mirrored_coordinate_table(
+    generate_phase2_ce_mtable(),
+    ce_solved,
+    ce_solved
+  );
 }
 function phase2_centre_goal_states() {
   let [itc, cti] = generate_comb4_lookup_tables(10, 5, 3, 2, 0);
@@ -1005,14 +1084,31 @@ function* phase2_ida_solve_gen(indices, moves_left) {
   let mirror_map = generate_phase2_ce_mirror_map();
   let [a, b, ce] = indices;
   let ce_mirror = mirror_map[ce];
-  let bound = Math.max(ptable_ace[a + 2520 * ce], ptable_ace[b + 2520 * ce_mirror]);
+  let bound = Math.max(
+    ptable_ace[a + 2520 * ce],
+    ptable_ace[b + 2520 * ce_mirror]
+  );
   while (bound <= moves_left) {
-    yield* phase2_ida_search_gen(a, b, ce, mtable_a, mtable_b, mtable_ce, ptable_ace, mirror_map, bound, -1);
+    yield* phase2_ida_search_gen(
+      a,
+      b,
+      ce,
+      mtable_a,
+      mtable_b,
+      mtable_ce,
+      ptable_ace,
+      mirror_map,
+      bound,
+      -1
+    );
     bound++;
   }
 }
 function* phase2_ida_search_gen(a, b, ce, mtable_a, mtable_b, mtable_ce, ptable_ace, mirror_map, bound, last) {
-  let h = Math.max(ptable_ace[a + 2520 * ce], ptable_ace[b + 2520 * mirror_map[ce]]);
+  let h = Math.max(
+    ptable_ace[a + 2520 * ce],
+    ptable_ace[b + 2520 * mirror_map[ce]]
+  );
   if (h > bound) {
     return;
   }
@@ -1030,7 +1126,18 @@ function* phase2_ida_search_gen(a, b, ce, mtable_a, mtable_b, mtable_ce, ptable_
       new_a = mtable_a[m][new_a];
       new_b = mtable_b[m][new_b];
       new_ce = mtable_ce[m][new_ce];
-      let subpath_gen = phase2_ida_search_gen(new_a, new_b, new_ce, mtable_a, mtable_b, mtable_ce, ptable_ace, mirror_map, bound - 1, m);
+      let subpath_gen = phase2_ida_search_gen(
+        new_a,
+        new_b,
+        new_ce,
+        mtable_a,
+        mtable_b,
+        mtable_ce,
+        ptable_ace,
+        mirror_map,
+        bound - 1,
+        m
+      );
       while (true) {
         let { value: subpath, done } = subpath_gen.next();
         if (done)
@@ -1209,10 +1316,16 @@ var phase3_2gen_move_seqs = [
     [7, 2]
   ]
 ];
-phase3_2gen_move_seqs = phase3_2gen_move_seqs.concat(phase3_2gen_move_seqs.map((seq) => invert_move_sequence(seq)));
+phase3_2gen_move_seqs = phase3_2gen_move_seqs.concat(
+  phase3_2gen_move_seqs.map((seq) => invert_move_sequence(seq))
+);
 var phase3_2gen_nmoves = phase3_2gen_move_seqs.length;
-var phase3_2gen_facelet_permutations = phase3_2gen_move_seqs.map((seq) => apply_move_sequence(permutation_from_cycles([], 72), seq));
-var phase3_2gen_piece_permutations = phase3_2gen_facelet_permutations.map(convert_move_to_permutations);
+var phase3_2gen_facelet_permutations = phase3_2gen_move_seqs.map(
+  (seq) => apply_move_sequence(permutation_from_cycles([], 72), seq)
+);
+var phase3_2gen_piece_permutations = phase3_2gen_facelet_permutations.map(
+  convert_move_to_permutations
+);
 var phase3_2gen_move_orders = phase3_2gen_facelet_permutations.map(permutation_order);
 function index_phase3_2gen(facelets) {
   let [itc, cti] = generate_comb4_lookup_tables(7, 3, 2, 0, 2);
@@ -1220,10 +1333,14 @@ function index_phase3_2gen(facelets) {
   let edge_coord = evenpermutation_to_index(ep);
   let corners = Array(4).fill().map((_, i) => get_corner_piece(facelets, i));
   let corner_coord = evenpermutation_to_index(corners.map((x) => x[0])) * 2 + corners.find((x) => x[0] === 0)[1];
-  let [a_coord, b_coord] = [centreA_piece_facelets, centreB_piece_facelets].map((facelet_indices) => {
-    let arr = compose(facelet_indices, phase3_2gen_centre_indices).map((x) => facelets[x] % 4);
-    return cti[arr.reduce((acc, x, j) => acc | x << 2 * j, 0)];
-  });
+  let [a_coord, b_coord] = [centreA_piece_facelets, centreB_piece_facelets].map(
+    (facelet_indices) => {
+      let arr = compose(facelet_indices, phase3_2gen_centre_indices).map(
+        (x) => facelets[x] % 4
+      );
+      return cti[arr.reduce((acc, x, j) => acc | x << 2 * j, 0)];
+    }
+  );
   return [a_coord + 210 * b_coord, corner_coord + 24 * edge_coord];
 }
 function generate_phase3_2gen_edge_mtable() {
@@ -1232,7 +1349,9 @@ function generate_phase3_2gen_edge_mtable() {
   }
   const HALFFACT5 = factorial(5) / 2;
   let mtable = Array(phase3_2gen_nmoves).fill().map(() => new Uint32Array(HALFFACT5));
-  let permutations = phase3_2gen_piece_permutations.map((x) => x.ep.slice(0, 5));
+  let permutations = phase3_2gen_piece_permutations.map(
+    (x) => x.ep.slice(0, 5)
+  );
   for (let i = 0; i < HALFFACT5; i++) {
     let p = index_to_evenpermutation(i, 5);
     for (let m = 0; m < phase3_2gen_nmoves; m++) {
@@ -1262,7 +1381,9 @@ function generate_phase3_2gen_corner_mtable() {
     false
   ];
   let mtable = Array(phase3_2gen_nmoves).fill().map(() => new Uint32Array(N));
-  let permutations = phase3_2gen_piece_permutations.map((x) => reduce_permutation(x.cp, keep).slice(0, 4));
+  let permutations = phase3_2gen_piece_permutations.map(
+    (x) => reduce_permutation(x.cp, keep).slice(0, 4)
+  );
   for (let i = 0; i < N; i += 2) {
     let p = index_to_evenpermutation(i >> 1, 4);
     let cp = p.concat(p.map((x) => x + 4));
@@ -1280,17 +1401,41 @@ function generate_phase3_2gen_corneredge_mtable() {
   if (cached_mtables.phase3_2gen_corneredge) {
     return cached_mtables.phase3_2gen_corneredge;
   }
-  return cached_mtables.phase3_2gen_corneredge = combine_mtables(generate_phase3_2gen_corner_mtable(), generate_phase3_2gen_edge_mtable());
+  return cached_mtables.phase3_2gen_corneredge = combine_mtables(
+    generate_phase3_2gen_corner_mtable(),
+    generate_phase3_2gen_edge_mtable()
+  );
 }
 function generate_phase3_2gen_centre_mtable() {
   if (cached_mtables.phase3_2gen_centre) {
     return cached_mtables.phase3_2gen_centre;
   }
-  let mtable_a = generate_mtable_comb4_generic(7, 3, 2, 0, 2, phase3_2gen_piece_permutations.map((x) => reduce_permutation(x.ap, phase3_2gen_keep)));
-  let mtable_b = generate_mtable_comb4_generic(7, 3, 2, 0, 2, phase3_2gen_piece_permutations.map((x) => reduce_permutation(x.bp, phase3_2gen_keep)));
+  let mtable_a = generate_mtable_comb4_generic(
+    7,
+    3,
+    2,
+    0,
+    2,
+    phase3_2gen_piece_permutations.map(
+      (x) => reduce_permutation(x.ap, phase3_2gen_keep)
+    )
+  );
+  let mtable_b = generate_mtable_comb4_generic(
+    7,
+    3,
+    2,
+    0,
+    2,
+    phase3_2gen_piece_permutations.map(
+      (x) => reduce_permutation(x.bp, phase3_2gen_keep)
+    )
+  );
   cached_mtables.phase3_2gen_centreA = mtable_a;
   cached_mtables.phase3_2gen_centreB = mtable_b;
-  return cached_mtables.phase3_2gen_centre = combine_mtables(mtable_a, mtable_b);
+  return cached_mtables.phase3_2gen_centre = combine_mtables(
+    mtable_a,
+    mtable_b
+  );
 }
 var phase3_2gen_ace_table;
 function generate_phase3_2gen_ace_table() {
@@ -1342,7 +1487,11 @@ function generate_phase3_2gen_ce_mirror_map() {
   }
   const mtable_ce = generate_phase3_2gen_corneredge_mtable().slice(0, 2);
   const solved_indices = index_phase3_2gen(solved_state);
-  return phase3_2gen_ce_mirror_map = generate_mirrored_coordinate_table(mtable_ce, solved_indices[1], solved_indices[1]);
+  return phase3_2gen_ce_mirror_map = generate_mirrored_coordinate_table(
+    mtable_ce,
+    solved_indices[1],
+    solved_indices[1]
+  );
 }
 function solve_phase3_2gen(facelets, indices = index_phase3_2gen(facelets)) {
   let [ab, ce] = indices;
@@ -1355,7 +1504,17 @@ function solve_phase3_2gen(facelets, indices = index_phase3_2gen(facelets)) {
   let mirror_map_ce = generate_phase3_2gen_ce_mirror_map();
   let bound = 0;
   while (true) {
-    let gen = solve_phase3_2gen_ida(a, b, ce, mtable_a, mtable_b, mtable_ce, ace_table, mirror_map_ce, bound);
+    let gen = solve_phase3_2gen_ida(
+      a,
+      b,
+      ce,
+      mtable_a,
+      mtable_b,
+      mtable_ce,
+      ace_table,
+      mirror_map_ce,
+      bound
+    );
     for (let solution of gen) {
       return solution.map((m) => phase3_2gen_move_seqs[m]).flat();
     }
@@ -1375,7 +1534,17 @@ function solve_phase3_2gen_readable(facelets, indices = index_phase3_2gen(facele
   let best_score = Infinity;
   let best_solution;
   for (let bound = initial; bound <= initial + 0; bound++) {
-    let gen = solve_phase3_2gen_ida(a, b, ce, mtable_a, mtable_b, mtable_ce, ace_table, mirror_map_ce, bound);
+    let gen = solve_phase3_2gen_ida(
+      a,
+      b,
+      ce,
+      mtable_a,
+      mtable_b,
+      mtable_ce,
+      ace_table,
+      mirror_map_ce,
+      bound
+    );
     for (let solution of gen) {
       let expanded = solution.map((m) => phase3_2gen_move_seqs[m]).flat();
       let simplified = simplify_move_sequence(expanded);
@@ -1443,7 +1612,18 @@ function* solve_phase3_2gen_ida(a, b, ce, mtable_a, mtable_b, mtable_ce, ace_tab
     if (new_bound < 0) {
       continue;
     }
-    let subpath_gen = solve_phase3_2gen_ida(new_a, new_b, new_ce, mtable_a, mtable_b, mtable_ce, ace_table, mirror_map_ce, new_bound, m);
+    let subpath_gen = solve_phase3_2gen_ida(
+      new_a,
+      new_b,
+      new_ce,
+      mtable_a,
+      mtable_b,
+      mtable_ce,
+      ace_table,
+      mirror_map_ce,
+      new_bound,
+      m
+    );
     while (true) {
       let { value: subpath, done } = subpath_gen.next();
       if (done) {
@@ -1499,7 +1679,9 @@ function solve_phase2_and_phase3_readable(facelets, phase2_attempts = 20, cap =
       let { value, done } = gen.next();
       if (!done) {
         let intermediate_facelets = apply_move_sequence(facelets, value);
-        let solution = simplify_move_sequence(value.concat(solve_phase3_2gen_readable(intermediate_facelets)));
+        let solution = simplify_move_sequence(
+          value.concat(solve_phase3_2gen_readable(intermediate_facelets))
+        );
         let score = grade_readability(solution);
         if (score <= cap) {
           return solution;
@@ -1513,7 +1695,9 @@ function solve_phase2_and_phase3_readable(facelets, phase2_attempts = 20, cap =
       let { value, done } = gen_t2.next();
       if (!done) {
         let intermediate_facelets = apply_move_sequence(facelets_t2, value);
-        let solution = simplify_move_sequence(value.concat(solve_phase3_2gen_readable(intermediate_facelets)));
+        let solution = simplify_move_sequence(
+          value.concat(solve_phase3_2gen_readable(intermediate_facelets))
+        );
         solution = solution.map(([m, r]) => [m ^ 2, r]);
         let score = grade_readability(solution);
         if (score <= cap) {
@@ -1534,4 +1718,4 @@ async function randomFTOScrambleString() {
 export {
   randomFTOScrambleString
 };
-//# sourceMappingURL=search-dynamic-solve-fto-O6UXF7EC.js.map
+//# sourceMappingURL=search-dynamic-solve-fto-4LI23P6K.js.map