Word!CPU

I have seen the Brainfuck CPU project, and a description of a INTERCAL CPU, but here is the new one!!!! Each command is 2 bytes (4 nybbles). The memory is from 0000h to 1FFFh, and there is 2 different sets of memory, the data memory and the program memory.
== CPU Pins ==
Memory: 13-bits address space, and one extra bit to indicate program memory or data memory. Both sets of memory are read/write. The data line of the memory is 1 byte (8 bits). There is also the clock which can be changed as often as it likes and not mess up anything. Each command takes the same amount of clock cycles (always). There is 2 sets of input, 8 bits each and 1 pin of each when getting the input, 2 sets of output, 8 bits of each and 1 pin of each when sending the output.
== Commands ==
There is 8 registers of 13 bits long indicating the memory address to access.
Block A commands: The format is (in bits) 000vvvvv vvvvvvv0 and the action is set instruction pointer to the value v (the address is always word-aligned so the 0 at the end is always a part of the address).
Block B commands: The format is (in bits) ccccxppp vvvvvvvv where c=Command, x=0 to access data memory or 1 to access program memory, p=which pointer to use for accessing memory, v=value.
* 2 = Add (v) to value at pointer, modulo 256.
* 3 = Move the pointer left by (v) number of spaces, wraps.
* 4 = Move the pointer right by (v) number of spaces, wraps.
* 5 = The value at the pointer is NAND by (v).
* 6 = Skip backward by (v) commands if value at pointer is non-zero. (v=0 lands here, causing a infinite loop without moving the instruction pointer.)
* 7 = Skip forward by (v) commands if value at pointer is zero. (v=0 lands on next command, just like any other command will do.)
* 8 = If v=0 then input from first set of input, if v=1 then input from second set of input, if v=2 then send output to first set of output, if v=3 then send output to second set of output.
Block C commands: The format is (in bits) 1111xppp ccccyrrr where c=command, x=0 to access data memory or 1 to access program memory, p=which pointer to use for accessing memory, r=which register to read or modify, y=0 to access low 8 bits of register or 1 to access the hi 5 bits (the other 3 are always set to zero).
* 0 = Put value of register to memory at pointer
* 1 = Copy value in memory to the value of the register
* 2 = Swap value in memory with the value of the register
* 3 = The value of the register is NAND by the value at the pointer
* 4 = The value at the pointer is NAND by the value of the register
Block D commands: The format is (in bits) ccccyrrr vvvvvvvv where c=command, r=which register to read or modify, y=0 to access low 8 bits of register or 1 to access the hi 5 bits (the other 3 are always set to zero), v=value.
* 9 = Set value of register to (v).
* A = Skip forward by (v) commands if value of the register is zero. (v=0 lands on next command, just like any other command will do.)
* B = Skip backward by (v) commands if value of the register is non-zero. (v=0 lands here, causing a infinite loop without moving the instruction pointer.)
== Examples ==
The programs are binary files, so these are their hexadecimal representations:
Cat
 80 00 80 02 20 01 60 03 20 01 60 40
Hello World
 00 12 48 65 6C 6C 6F 2C 20 57 6F 72 6C 64 21 0A
 00 00 40 02 88 02 40 01 68 02 B0 40
== Notes ==
* When executing a command, it will always read the entire command first, and then read value of memory if required, and then it will execute that command and move instruction pointer.
== External resources ==
* Interpreter