The ALU has two 8 bit input registers, P and Q (for the two operands) and
a flags register (2 bits: Z and C). The ALU is built of two 64k eproms,
each a 4 bit slice ALU, with carry, shr and zero.


ALU slice input (MSB to LSB):
	- 5 bit instruction (32 instructions)
	- carry in from prev stage (or flag)
	- shr: shift-left-to-right
	- Z flag
	- 4 bit Q
	- 4 bit P

ALU slice output (MSB to LSB):
	- 1 bit carry
	- 1 bit shr
	- 1 bit Z flag
	- (1 bit unused)
	- 4 bits result (R)

Instructions:

 0   prp     R:=P                (print register value)
 1   prq     R:=Q                (print register value)
 2   prz     R:=Z-flag           (print Z flag)
 3   prc     R:=C-flag           (print C flag)
 4   <unused>
 5   inc     R:=P+1
 6   dec     R:=P-1
 7   add     R:=P+Q
 8   sub     R:=P-Q
 9   addc    R:=P+Q+carry
 10  subc    R:=P-Q-carry
 11  or      R:=P | Q
 12  and     R:=P & Q
 13  xor     R:=P ^ Q            (xor)
 14  neg     R:=~P               (bitwise negate)
 15  shr     R:=P>>1             (right shift)
 16  shl     R:=P<<1             (left shift)
 17  bset    R:=P | (1 << Q)     (bit set)
 18  bclr    R:=P & ~(1 << Q)    (bit clear)


These have to go in a dedicated hardware mul board:
 xx  Q*P & 0x0FF      (low byte of Q*P)
 xx  Q*P >> 8         (high byte of Q*P)
 xx  Q / P            (integer div)
 xx  Q % P            (modulo)