You are given a list of non-negative integers `nums`, a `bucket_count` that is guaranteed to be a power of two, an `align` value that is also a power of two, and an integer `threshold`. Simulate the following integer-heavy inner loop and return the final `scores` array: `scores = [0] * bucket_count` `for x in nums:` ` bucket = x & (bucket_count - 1)` ` ones = popcount(x)` ` signed = ones if ones >= threshold else -ones` ` delta = signed if x is aligned to align else -signed` ` scores[bucket] += delta` Here, `popcount(x)` is the number of set bits in `x`, and `x` is aligned to `align` when `x % align == 0`. This problem intentionally mirrors common bit-level performance tricks: - `x & (bucket_count - 1)` replaces modulo when `bucket_count` is a power of two. - `x.bit_count()` is a population count. - A branchless select can be written as `b ^ ((a ^ b) & mask)` with `mask = -int(condition)`. - Alignment can be checked with `(x & (align - 1)) == 0`. Why these tricks are correct: for powers of two, masking keeps exactly the low bits needed for modulo, and alignment means those same low bits are all zero. On real CPUs, these transformations avoid expensive division, reduce unpredictable branches that can cause pipeline stalls, expose more instruction-level parallelism, and keep the hot `scores` array cache-friendly, reducing memory traffic.