+The first floor contains a 1 generator, a 2 generator, a 2-compatible microchip, a 3 generator, a 4 generator, a 5 generator, a 5-compatible microchip, a 6 generator, a 6-compatible microchip, a 4-compatible microchip, a 7 generator, and a 7-compatible microchip.

+The second floor contains a 1-compatible microchip and a 3-compatible microchip.

+The third floor contains nothing relevant.

+The fourth floor contains nothing relevant.

+ pattern_types,

+ pattern_type_macro,

+ pattern_type_range_trait,

+ const_trait_impl,

+ hash::Hash,

+ ops::{Coroutine, Deref},

+impl Debug for Item {

+ fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {

+ write!(f, "{} {:?}", self.name.get(), self.kind)

+ }

+}

+#[derive(Clone, Copy, PartialEq, Eq, Hash, PartialOrd, Ord)]

+struct Item {

+ name: identifier,

+ kind: ItemK,

+}

+#[derive(Clone, Copy, Debug)]

+#[repr(u8)]

+enum identifier {

+ u1,

+ u2,

+ u3,

+ u4,

+ u5,

+ u6,

+ u7,

+ u8,

+ u9,

+}

+impl identifier {

+ fn get(self) -> u8 {

+ self as u8

+impl PartialEq for identifier {

+ fn eq(&self, other: &Self) -> bool {

+ self.get() == other.get()

+ }

+}

+impl Eq for identifier {}

+impl PartialOrd for identifier {

+ fn partial_cmp(&self, other: &Self) -> Option<std::cmp::Ordering> {

+ self.get().partial_cmp(&other.get())

+ }

+}

+impl Ord for identifier {

+ fn cmp(&self, other: &Self) -> std::cmp::Ordering {

+ self.get().cmp(&other.get())

+ }

+}

+impl Hash for identifier {

+ fn hash<H: std::hash::Hasher>(&self, state: &mut H) {

+ self.get().hash(state)

+ }

+}

+#[derive(Clone, Copy, Debug, PartialEq, Eq, Hash, PartialOrd, Ord)]

+enum ItemK {

+ Chip,

+ Gen,

+}

+use ItemK::*;

+pub unsafe fn p1(x: &'static [u8; ISIZE]) -> impl Debug {

+ let re = Regex::new(r"([0-9a-z]+) generator").unwrap();

+ let rechip = Regex::new(r"([0-9a-z]+)-compatible microchip").unwrap();

+ let mut floors = vec![vec![]; 4];

+ x.行().zip(&mut floors).for_each(|(x, to)| {

+ to.extend(re.captures_iter(x).map(|x| Item {

+ name: transmute(x.get(1).unwrap().as_bytes()[0] - b'0'),

+ kind: Gen,

+ }));

+ to.extend(rechip.captures_iter(x).map(|x| Item {

+ name: transmute(x.get(1).unwrap().as_bytes()[0] - b'0'),

+ kind: Chip,

+ }));

+ });

+ // if a chip is ever left in the same area as another RTG, and it's not connected to its own RTG, the chip will be fried.

+ fn not_fried(floor: impl Iterator<Item = Item> + Clone) -> bool {

+ floor.clone().all(_.kind == Chip)

+ || floor

+ .clone()

+ .filter(_.kind == Chip) // every chip

+ .all(|x| floor.clone().filter(_.kind == Gen).any(_.name == x.name)) // is connected

+ };

+ util::steps_astar(

+ (0, floors),

+ |(e, floor)| {

+ [(e < 3).then(|| e + 1), (e > 0).then(|| e - 1)]

+ .into_iter()

+ .flatten()

+ .flat_map(move |v| {

+ floor[e]

+ .clone()

+ .into_iter()

+ .ι()

+ .tuple_combinations()

+ .map(|(a, b)| vec![a, b])

+ .chain(floor[e].clone().into_iter().ι().map(|a| vec![a]))

+ .map({

+ let floor = floor.clone();

+ move |mut x| {

+ let mut floor = floor.clone();

+ floor[v].extend(x.iter().map(|x| x.0));

+ x.sort_by_key(|x| x.1);

+ x.iter().rev().map(|(_, i)| floor[e].swap_remove(*i)).θ();

+ floor[v].sort();

+ floor[e].sort();

+ (v, floor)

+ }

+ })

+ })

+ .filter(|(e, floor)| not_fried(floor[*e].iter().copied()))

+ .map(|n| (n, 1))

+ },

+ |x| -(x.1[3].len() as i16),

+ |(_, f)| f[0..3].iter().all(_.is_empty()),

+ )

+ unsafe { println!("{:?}", p1(include_bytes!("inp.txt"))) };

+ intrinsics::transmute_unchecked as transmute,

+ mem::{replace as rplc, swap},

+#[derive(Debug, Clone, Copy)]

+pub struct Left<T, U>(T, U);

+impl<T: Hash, U> Hash for Left<T, U> {

+ fn hash<H: std::hash::Hasher>(&self, state: &mut H) {

+ self.0.hash(state);

+ }

+}

+

+impl<T: PartialEq, U> PartialEq for Left<T, U> {

+ fn eq(&self, other: &Self) -> bool {

+ self.0 == other.0

+ }

+}

+impl<T: Eq, U> Eq for Left<T, U> {}

+impl<T: PartialOrd, U> PartialOrd for Left<T, U> {

+ fn partial_cmp(&self, other: &Self) -> Option<std::cmp::Ordering> {

+ self.0.partial_cmp(&other.0)

+ }

+}

+impl<T: Ord, U> Ord for Left<T, U> {

+ fn cmp(&self, other: &Self) -> std::cmp::Ordering {

+ self.0.cmp(&other.0)

+ }

+}

+pub fn steps<N: Debug + Eq + Hash + Clone, I: Iterator<Item = N>>(

+) -> Option<Left<N, usize>> {

+ Left(start, 0usize),

+ |Left(n, steps)| graph(n).map(move |x| Left(x, steps + 1)),

+pub fn steps_astar<N: Debug + Eq + Hash + Clone, I: Iterator<Item = (N, i16)>>(

+ start: N,

+ graph: impl Fn(N) -> I,

+ heuristic: impl Fn(&N) -> i16,

+ goal: impl Fn(&N) -> bool,

+) -> Option<(i16, Left<N, usize>)> {

+ astar(

+ Left(start, 0usize),

+ |Left(n, steps)| graph(n).map(move |(x, cost)| (Left(x, steps + 1), cost)),

+ |x| heuristic(&x.0),

+ |x| goal(&x.0),

+ )

+}

+

+ let mut s = HashSet::with_capacity_and_hasher(1024, rustc_hash::FxBuildHasher::default());

+ if s.len() % (1 << 20) == 0 {

+ dbg!(s.len());

+ }

+ }

+ None

+}

+

+pub fn astar<N: Debug + Eq + Hash + Clone, I: Iterator<Item = (N, i16)>>(

+ start: N,

+ graph: impl Fn(N) -> I,

+ heuristic: impl Fn(&N) -> i16,

+ goal: impl Fn(&N) -> bool,

+) -> Option<(i16, N)> {

+ let mut q = BinaryHeap::with_capacity(1024);

+ let mut score = HashMap::default();

+ score.insert(start.clone(), 0);

+ q.push(Reverse(Left(heuristic(&start), start)));

+ while let Some(Reverse(Left(c, n))) = q.pop() {

+ if goal(&n) {

+ return Some((c, n));

+ }

+ for (n_, d) in graph(n.clone()) {

+ let g = score[&n] + d;

+ let of = score.get(&n_).unwrap_or(&i16::MAX);

+ if g < *of {

+ score.insert(n_.clone(), g);

+ let f = g + heuristic(&n_);

+ q.push(Reverse(Left(f, n_)));

+ }

+ }

+ q.push(Reverse(Left(0, start)));

+ while let Some(Reverse(Left(c, n))) = q.pop() {

+ q.push(Reverse(Left(c + d, n)));