So, of course we choose to use the * 6502*, that we already finished for the

*. The only thing we need to add, is the*

**NES***ability, that the*

**BCD***C64*makes use of in the

*6502*(the

*NES*doesn’t, it’s actually completely disabled by a cut trace on the

*PCB*).

*BCD *often sounds very complex and frustrating, yet it isn’t that bad at all. For this, we have to dive into number systems a tiny bit (which shouldn’t be bothering you at all, given the fact that you read this page in general).

Example ------- Hex: 0x23 2 * 16 = 32 + 3 * 1 = 3 --------------- 35

This is the way that we usually interpret a hex number in our minds, because we are trained to use a base10 number system. This is exactly what BCD makes use of. Instead of treating the hex value for a hex value, we simply treat it as a base10 number.

For the above example, we will treat 0x23 as simple 23, not 35. This is all that BCD takes. Therefore, all numbers that contain letters are invalid.

Extended explanation:

BCD Add 0x45 + 0x33 = 0x78

So, the flagging for the ** decimal flag** inside the

*we already did for the NES, but now we have to make use of it. The only 2 instructions that actually use*

**PSW***BCD*are

**ADC and SBC**. Since we made a unified function for both of these opcodes, we can simply implement it at that point.

```
if (status.decimal == 0) {
uint16_t sum = registers.A + val + status.carry;
status.setOverflow((~(registers.A ^ val) & (registers.A ^ sum) & 0x80) > 0);
status.setCarry(sum > 0xff);
registers.A = sum & 0xff;
status.setZero(registers.A == 0);
status.setNegative(registers.A >> 7);
}
else {
printf("BCD Arithmetik happening\n");
uint16_t v1 = (registers.A / 16) * 10 + (registers.A % 16);
uint16_t v2 = (val / 16) * 10 + (val % 16);
uint16_t sum = ((v1 + v2 + status.carry) / 10 * 16) + (v1 + v2 + status.carry) % 10;
status.setCarry((v1 + v2) > 99);
registers.A = sum & 0xff;
}
```

## Comments