 This time we're going to be looking at the data memory and we're going to be interested in what happens when bit zero of the address is stuck at zero or stuck at one. So this is the least significant bit in our address and that determines which piece of data we would potentially read or write from memory. If this bit is stuck at zero then I won't be able to access any of the odd numbered bytes of memory directly. I could still get them indirectly by pulling in say four bytes at a time or two bytes at a time. As we've built our architecture so far we haven't even considered load byte or store byte instructions so this wouldn't even be a concern for us. We'd never be interested in accessing an odd numbered byte directly. If we did have a load byte instruction then this might potentially be a problem. If we are interested in grabbing an odd numbered bit then we'd have to find some way to work around that. Instead of having a load byte instruction I could have a load half instruction instead and then just shift the lower half of my data out of the register. A store byte would be more troublesome because I would have to pull the data out of memory using a load half instruction, edit that register and then store the resulting half back into memory. So that would be a multi-step process and it would be cumbersome but that would still be workable. If this bit is stuck at one though I'll only be able to access the odd numbered bytes directly. This would be a problem if I want to do a load half or a load word since both of those instructions expect that I will give them an even numbered address. The load word expects an address that's a multiple of four so that has an even stricter constraint on it. In this case our data memory would probably just reject all of those. It would keep telling us that these are not word aligned addresses or half aligned addresses and it would throw exceptions. In this case there's not a good way to work around this. The full MIPS architecture however does provide some instructions that allow you to access non word aligned blocks of memory so you could still pull out four bytes of memory even if they're not word aligned. So there would be the option to switch to non-aligned accesses and doing some shifting the way we did when we were looking at the stuck at zero byte but otherwise we're out of luck. There isn't a good way to replace this type of instruction with another one because the hardware is going to catch this as an error.