size = 42

size = 24

data Node a = Node { ix :: Int , atom :: a }
data Verse a = Verse { radius :: Int , nodes :: V.Vector (Node a) , neighbours :: V.Vector (U.Vector Int) }

data Node a = Node
   { ix :: Int
   , atom :: a
   }
data Verse a = Verse
   { radius :: Int
   , nodes :: V.Vector (Node a)
   , neighbours :: U.Vector Int  -- flattened vector[n][dir] -> vector[n*6+dir]
   }

      , neighbours = V.generate (3 * r * r) (\i -> U.generate 6 (\n -> shift Verse { radius = r } 1 (toEnum n) i))

      , neighbours = U.generate (3 * r * r * 6) (\i -> shift Verse { radius = r } 1 (toEnum $ mod i 6) (div i 6))

neighbour v i dir = U.unsafeIndex (V.unsafeIndex (neighbours v) i) (fromEnum dir)

neighbour v i dir = U.unsafeIndex (neighbours v) (i * 6 + fromEnum dir)

terra :: (Eq a, Enum a, Ord a, Bounded a) => Int -> Cell () a

terra :: forall a. (Eq a, Enum a, Ord a, Bounded a) => Int -> Cell () a

      go :: (Int, Int, Int) -> a -> (Int, Int, Int)

dois :: (Eq a, Enum a, Bounded a, Ord a, Num a) => Cell () a

dois :: forall a. (Eq a, Enum a, Bounded a, Ord a, Num a) => Cell () a

   adjacents :: [a]

bees :: (Eq a, Enum a, Bounded a, Ord a) => Cell () a

bees :: forall a. (Eq a, Enum a, Bounded a, Ord a) => Cell () a

   | gt ∈ [2 :: Int] = next a
   | lt ∈ [2 :: Int] = a

   | gt ∈ [2] = next a
   | lt ∈ [2] = a

   (lt,gt) = foldl' go (minBound , minBound) $ ns <$> total

   lt,gt :: Int
   (lt,gt) = foldl' go (0,0) $ ns <$> total

      go :: (Int, Int) -> a -> (Int, Int)

   tops :: Int