 So now that we've got our one-bit ALU here, I'm going to draw a nice box around this and we're going to abstract that part a bit away. So I've got several inputs here. I've got A, B, as well as A-invert, B-invert carry-in on my operation and I get a result and a carry-out out of this box. If I take these boxes and I connect them kind of the way we've done before with, say, our adders where our carry-out from first one feeds in as the carry-out to the next, then I could stack up, say, 32 of these which would enable me to do my addition. So I'd have 32 of them all the way from 0 to 31, each of which is getting a different pair of input bits for A and B and producing a corresponding result bit. Now we have all of the control signals. So I have an A-invert line and I definitely need to pass this one to each one of the one-bit ALUs that I've got. In order to do NOR or NAND, I need to invert all of my A's and all of my B's. So there's my A-invert line. I will do the same thing for my B-invert. So now I can invert A or B as I want. Next I'll add in the operation. So that will work the same way as the others. We really want to just feed that into each of these. Lastly, I have that carry-in, except that in this case the carry-in is generally bound to the carry-out of the previous ALU. So we only have one carry-in here actually. And let's take a minute and think about when we turn that on. When do we assert the carry-in? When do we not assert it? We only use that carry-in to do the subtraction operation. Otherwise, if we're doing addition, then we set the carry-in to zero. If we're doing a logical operation instead, then we don't care what the adder does anyway. So it doesn't matter if the carry-in is zero or one. Turns out the carry-in is always the same as the B-invert line, at least for the topmost ALU. For the others, obviously it's bound to the previous carry-out. But this means I can actually use this B-invert line as my carry-in line as well. So I can make it a little note that that's also carry-in as well as B-invert. But that's only true for the top ALU. For all the others, the carry-in is bound to the previous carry-out. So this will give me a 32-bit ALU. I've stacked up 32 of our 1-bit ALUs. I've connected all of our signals to where they need to go. When we use one of these multi-bit ALUs later, we will be using this symbol. We still have our A and B for inputs as well as our opcode. But we'll pretty much just join all four of our signals into one line and not worry about all of the details. We no longer have to worry about how does our ALU actually work? How is it doing its computation? How does it determine which of these operations do we want to run? All of that can just be put into one ALU. So we will just have this symbol that we'll work with later. And that's all we'll have to worry about.