lda     [regPC]         ; Load 16-bit value from 24-bit address         ( 7)
        and     #$00FF          ; We only want the bottom 8-bits...             (+3)
        asl                     ; Double for indexing in 16-bit wide jump table (+2)
        tax                     ; X used to index into jump table               (+2)

; Increment the PC

        inc     regPC+0                 ; Low word                              (+7)
        beq     incH                    ; 2 cycles + 1 when branch taken        (+2) = 23

        jmp     (opcodeJumpTable,x)     ;                                       (+6) = 29

incH:   inc     regPC+2                 ; Top word                              (23 + 1 + 7)
        jmp     (opcodeJumpTable,x)     ;                                       (+6) = 37

pflag:
    tax                 ; accumulator holds value of last calculation
    stz pflag_tmp       ; clear the temp value holder
    txa
    pha                 ; save accumulator for exit
    ldy #$08            ; we are going to loop through each bit
pflag_loop:
    clc                 ; clear the carry
    rol                 ; roll the bits left, putting leftmost in carry flg
    bcc +               ; if carry is clear, this bit should be skipped
    inc pflag_tmp       ; otherwise, temp value = temp value + 1
+   dey                 ; count down
    beq pflag_clrset    ; if zero, move on
    jmp pflag_loop      ; loop and roll next bit
pflag_clrset:
    lda pflag_tmp       ; get the temp value (number of bits with 1's in them)
    and #$01            ; is the 0th bit = 1?  (if so, its an odd number)
    bne pflag_clr       ; its an even number - skip ahead
    lda FRL             ; get the 8086 register flag
    ora #$04            ; set bit 4
    sta FRL             ; store it
    jmp pflag_done      ; we are done
pflag_clr:
    lda FRL             ; its an off number. get the 8086 register flag
    and #$fb            ; clear bit 4
    sta FRL             ; store it
pflag_done:
    pla                 ; get our original A value
    rts                 ; done
pflag_tmp:
.byte $00

loop:
    lsr
    beq done
    bcc loop
    eor #1
    jmp loop
done:

LDA #4
AND flags
EOR #4
STA paritydata

pflag:
    pha         ; save a
    ldy #0      ; bit counter
pcount:
    iny         ;
ploop:
    lsr         ;
    bcs pcount  ;
    bne ploop   ;
    tya         ; a now holds # of 1 bits (+1)
    and #1      ; isolate parity bit
    asl         ; move it to bit #2
    asl         ;
    eor FRL     ;
    and #4      ;
    eor FRL     ;
    sta FRL     ; insert parity bit into FRL
    pla         ; restore a
    rts         ;

pflag:
    pha         ; save a
pcount:
    lsr
    beq pdone
    bcc pcount
    eor #1
    bcs pcount
pdone:
    rol         ; parity bit was in C
    eor #1      ; invert it
    asl         ; move it to bit #2
    asl         ;
    eor FRL     ;
    and #4      ;
    eor FRL     ;
    sta FRL     ; insert parity bit into FRL
    pla         ; restore a
    rts         ;