C++ fast engine

inline const std::array<RunInfo8, 128> kRunLengthTable = [] {
  std::array<RunInfo8, 128> table{};
  for (int mask = 0; mask < 128; ++mask) {
    RunInfo8& info = table[static_cast<std::size_t>(mask)];
    for (int position = 0; position < kBoardSize; ++position) {
      info.length[position] = 0;
    }
    int cursor = 0;
    while (cursor < kBoardSize) {
      if (((mask >> cursor) & 1) == 0) {
        ++cursor;
        continue;
      }
      const int start = cursor;
      while (cursor < kBoardSize && ((mask >> cursor) & 1) != 0) ++cursor;
      for (int position = start; position < cursor; ++position) {
        info.length[position] = static_cast<std::uint8_t>(cursor - start);
      }
    }
  }
  return table;
}();

// One pass over the board produces the seven row occupancy masks, the seven
// column occupancy masks and the bitboard of numbered cells.  The cover
// bitboard is deliberately NOT produced here: better than half of all move
// applications resolve with no wave at all, and those never need it.
inline void scanBoard(const Board& board, BoardScan& scan) {
  unsigned rows[kBoardSize];
  std::uint64_t numbered = 0;
  for (int row = 0; row < kBoardSize; ++row) {
    const std::uint8_t* cells = board.data() + row * kBoardSize;
    unsigned occupied = 0;
    unsigned numbers = 0;
    for (int column = 0; column < kBoardSize; ++column) {
      const unsigned cell = cells[column];
      occupied |= static_cast<unsigned>(cell != 0u) << column;
      numbers |= static_cast<unsigned>(cell - 1u < 7u) << column;
    }
    rows[row] = occupied;
    scan.row_mask[row] = static_cast<std::uint8_t>(occupied);
    numbered |= static_cast<std::uint64_t>(numbers) << (row * kBoardSize);
  }
  for (int column = 0; column < kBoardSize; ++column) {
    unsigned mask = 0;
    for (int row = 0; row < kBoardSize; ++row) {
      mask |= ((rows[row] >> column) & 1u) << row;
    }
    scan.column_mask[column] = static_cast<std::uint8_t>(mask);
  }
  scan.numbered = numbered;
}

// Only a column that lost a disc can have a hole; reveals overwrite a cover in
// place and leave the column contiguous.  Compacting just the affected columns
// is therefore identical to compacting all seven.
inline void applyGravityInPlace(Board& board, unsigned columns) {
  while (columns != 0) {
    const int column = __builtin_ctz(columns);
    columns &= columns - 1;
    int destination = kBoardSize - 1;
    for (int row = kBoardSize - 1; row >= 0; --row) {
      const std::uint8_t cell =
          board[static_cast<std::size_t>(row * kBoardSize + column)];
      if (cell == kEmpty) continue;
      board[static_cast<std::size_t>(destination * kBoardSize + column)] = cell;
      --destination;
    }
    for (int row = destination; row >= 0; --row) {
      board[static_cast<std::size_t>(row * kBoardSize + column)] = kEmpty;
    }
  }
}

// ---------------------------------------------------------------------------
// O5.  Wave sinks.  The search discards MoveResult::waves entirely; only
// `empty()` and `back().depth` are consulted inside playMove.  A vector is
// therefore a per-node heap allocation for data nobody reads.  Trajectory
// consumers get the full list through FullWaveSink, which stores it inline.
// ---------------------------------------------------------------------------

struct MinimalWaveSink {
  int count = 0;
  int last_depth = 0;

  void push(const Wave& wave) {
    ++count;
    last_depth = wave.depth;
  }
  bool empty() const { return count == 0; }
  int backDepth() const { return last_depth; }
};

// A move can pop at most 49 discs, and every wave clears at least one disc, so
// a single move produces at most 49 waves before the rise and at most 49 after
// it.  128 is a hard upper bound with margin; overflow throws rather than
// silently truncating.
inline constexpr int kMaximumWavesPerMove = 128;

struct FullWaveSink {
  std::array<Wave, kMaximumWavesPerMove> waves;
  int count = 0;

  void push(const Wave& wave) {
    if (count >= kMaximumWavesPerMove) {
      throw std::runtime_error("fast engine: wave capacity exceeded");
    }
    waves[static_cast<std::size_t>(count++)] = wave;
  }
  bool empty() const { return count == 0; }
  int backDepth() const { return waves[static_cast<std::size_t>(count - 1)].depth; }
};

struct PackedKey {
  std::uint64_t words[4] = {0, 0, 0, 0};

  bool operator==(const PackedKey& other) const {
    return words[0] == other.words[0] && words[1] == other.words[1] &&
           words[2] == other.words[2] && words[3] == other.words[3];
  }
};

// Injective on the reachable domain: cells are 0..9 (4 bits), next_disc 1..7,
// moves_remaining 1..5, depth 1..8.  gate-search asserts the domain bounds on
// every key it builds.
inline PackedKey packKey(const State& state, int depth) {
  PackedKey key;
  const std::uint8_t* cells = state.board.data();
  for (int group = 0; group < 3; ++group) {
    std::uint64_t word = 0;
    for (int offset = 0; offset < 16; ++offset) {
      word |= static_cast<std::uint64_t>(cells[group * 16 + offset] & 0x0fu)
              << (4 * offset);
    }
    key.words[group] = word;
  }
  key.words[3] = static_cast<std::uint64_t>(cells[48] & 0x0fu) |
                 (static_cast<std::uint64_t>(state.next_disc) << 8) |
                 (static_cast<std::uint64_t>(
                      static_cast<std::uint32_t>(state.moves_remaining))
                  << 16) |
                 (static_cast<std::uint64_t>(static_cast<std::uint32_t>(depth))
                  << 24);
  return key;
}