So now we know how to compact in parallel, but only if we figure out how to compute the scatter addresses efficiently and in parallel. So let's take a closer look at the computation that we need to do here. We're going to have a set predicates here-- true, false, false, true, true, false, true, false. And what we need to do is compute the scatter addresses that will result from this string of predicates. Since we don't care about the scatter addresses for the false values, we'll just put a dash for don't care. Our algorithm is going to generate something there, it just doesn't matter what it generates. Again, our goal is to input this predicate string and output this string of addresses. And now we'll do a simple substitution. Whenever we see a true here, we'll substitute the number 1. Whenever we see a false here, we'll substitute the number 0. And rather than "don't cares" I'm actually going to fill in some values here. So we're going to have the strings 0, 1, 1, 1, 2, 3, 3, 4. So here's our input, a bunch of trues and falses. We're translating it into 1s and 0s, and this is our output, our set of addresses here. And now perhaps the shortest quiz of the course. If this is the input, and this is the output, what is the operation we need to do to get from this input to this output? Hint. Your answer is 1 word, of 4 letters.