Switch to direct dbg!(…) for more compact state debugging.

src/rs/scramble/puzzles/square1.rs

@@ -256,6 +256,7 @@ pub fn scramble_square1() -> Alg {
             continue;
         }
 
+<<<<<<< Updated upstream
         println!(
             "{}",
             serde_json::to_string_pretty(&phase1_start_pattern.to_data()).unwrap()
@@ -379,6 +380,121 @@ pub fn scramble_square1() -> Alg {
                     "{}",
                     serde_json::to_string_pretty(&scramble_pattern.to_data()).unwrap()
                 );
+||||||| Stash base
+=======
+        dbg!(&phase1_start_pattern);
+
+        // dbg!(
+        //     &phase1_start_pattern
+        //         .apply_alg(&parse_alg!("(3, 3) / (-1, 1)"))
+        //         .unwrap()
+        //         == square1_square_square_shape_kpattern()
+        // );
+        // <<<
+        dbg!(&square1_square_square_shape_kpattern());
+
+        // <<< if let Some(solution) = simple_filtered_search(&phase1_start_pattern, generators, 11, None) {
+
+        // let direct = simple_filtered_search::<AlwaysValid>(
+        //     &phase1_start_pattern,
+        //     generators.clone(),
+        //     0,
+        //     None,
+        // )
+        // .unwrap();
+        // println!("{}", direct);
+
+        let mut phase1_filtered_search = FilteredSearch::<Phase1Checker>::new(
+            kpuzzle,
+            generators.clone(),
+            None,
+            square1_square_square_shape_kpattern().clone(),
+        );
+
+        // let generators2 = generators_from_vec_str(vec!["US", "DS", "UUU", "DDD"]); // TODO: cache
+        let mut phase2_filtered_search = FilteredSearch::<Phase2Checker>::new(
+            kpuzzle,
+            generators,
+            None, // TODO
+            kpuzzle.default_pattern(),
+        );
+        // phase2_filtered_search
+        //     .idfs
+        //     .prune_table
+        //     .extend_for_search_depth(11, 6140878);
+
+        println!("PHASE1ING");
+
+        let start_time = Instant::now();
+        let mut odd_parity_counter = 0;
+        let mut num_phase2_starts = 0;
+        let mut phase1_start_time = Instant::now();
+        let mut phase1_cumulative_time = Duration::default();
+        let mut phase2_cumulative_time = Duration::default();
+        let mut parity_check_cumulative_time = Duration::default();
+        'phase1_loop: for mut phase1_solution in phase1_filtered_search.search(
+            &phase1_start_pattern,
+            Some(10_000_000), // see "le tired' below
+            None,
+            Some(18), // Max phase 1 length
+        ) {
+            phase1_cumulative_time += Instant::now() - phase1_start_time;
+
+            let phase2_start_pattern_for_parity =
+                scramble_pattern.apply_alg(&phase1_solution).unwrap();
+
+            // println!("--------\n{}", phase1_solution);
+            let parity_check_start_time = Instant::now();
+            let par = wedge_parity(&phase2_start_pattern_for_parity);
+            // println!("{:?}", par);
+            // println!("{:?}", wedge_parity(&kpuzzle.default_pattern()
+            //     .apply_alg(&parse_alg!("(0, 5) / (3, 0) / (-5, -2) / (3, -3) / (5, -4) / (0, -3) / (-3, 0) / (-3, -3)")).unwrap()
+            //     .apply_alg(&phase1_solution).unwrap())
+            // );
+            // println!("{:?}", par == BasicParity::Odd);
+            parity_check_cumulative_time += Instant::now() - parity_check_start_time;
+            if par == BasicParity::Odd {
+                odd_parity_counter += 1;
+                phase1_start_time = Instant::now();
+                continue;
+            }
+
+            while let Some(cubing::alg::AlgNode::MoveNode(r#move)) = phase1_solution.nodes.last() {
+                if r#move == &parse_move!("_SLASH_'")
+                // TODO: redundant parsing
+                {
+                    break;
+                }
+                // Discard equivalent phase 1 solutions (reduces redundant phase 2 searches by a factor of 16).
+                if r#move.amount > 2 || r#move.amount < 0 {
+                    phase1_start_time = Instant::now();
+                    continue 'phase1_loop;
+                }
+                phase1_solution.nodes.pop();
+            }
+
+            let phase2_start_pattern = scramble_pattern.apply_alg(&phase1_solution).unwrap();
+
+            num_phase2_starts += 1;
+            // println!("\n{}", phase1_solution);
+            // println!("\nSearching for a phase2 solution");
+            print!(".");
+            let _ = stdout().flush();
+            let phase2_solution = phase2_filtered_search
+                .search(
+                    &phase2_start_pattern,
+                    Some(1),
+                    None,
+                    Some(17), // <<< needs explanation
+                )
+                .next();
+
+            let phase2_start_time = Instant::now();
+            if let Some(mut phase2_solution) = phase2_solution {
+                let mut nodes = phase1_solution.nodes;
+                nodes.append(&mut phase2_solution.nodes);
+                dbg!(&scramble_pattern.to_data());
+>>>>>>> Stashed changes
 
                 // <<< return Alg { nodes }.invert()
                 return Alg { nodes }; // because slash' is not a valid move we can print