anchor.diff:  
           let PushPBrk () =
               b <- true
  -            WriteMemoryS (GetP())
  +            GetP() |> WriteMemoryS
               i <- true
               ea <- brkVector
   
           let PushPIrq () =
               b <- false
  -            WriteMemoryS (GetP())
  +            GetP() |> WriteMemoryS
               i <- true
               ea <- irqVector
               
           let PushPNmi () =
               b <- false
  -            WriteMemoryS (GetP())
  +            GetP() |> WriteMemoryS
               i <- true
               ea <- nmiVector
   
  
positive.code:                     c <- (binaryResult &&& 0x40) <> 0
                      v <- (binaryResult &&& 0x40) <> ((binaryResult &&& 0x20) <<< 1)
                      binaryResult
  
          let Lxa () =
              a <-
                  let result = (a ||| config.LxaConstant) &&& x &&& aluTemp
                  NZ result
                  result
  
          let Sbc () =
              let inline setV value result =
                  v <- ((a ^^^ value) &&& 0x80) &&& ((a ^^^ result) &&& 0x80) <> 0
  
              let binaryResult = a - aluTemp - (if c then 0 else 1)
              a <-
                  if isDecimalMode then
                      let initialSub = (a &&& 0x0F) - (aluTemp &&& 0x0F) - (if c then 0 else 1)
                      let adjustedSub =
                          if (initialSub &&& 0x10) <> 0 then
                              ((initialSub - 6) &&& 0x0F) ||| ((a &&& 0xF0) - (aluTemp &&& 0xF0) - 0x10)
                          else
                              (initialSub &&& 0x0F) ||| ((a &&& 0xF0) - (aluTemp &&& 0xF0))
                      let result = (if (adjustedSub &&& 0x100) <> 0 then (adjustedSub - 0x060) else adjustedSub)
                      z <- (binaryResult &&& 0xFF) = 0
                      n <- (binaryResult &&& 0x80) <> 0
                      c <- binaryResult < 0x100
                      setV aluTemp binaryResult
                      result
                  else
                      NZ binaryResult
                      c <- binaryResult > 0xFF
                      setV aluTemp binaryResult
                      binaryResult
  
          let Adc () =
              let inline setV value result =
                  v <- (((a ^^^ value) &&& 0x80) ^^^ 0x80) &&& ((a ^^^ result) &&& 0x80) <> 0
  
              let binaryResult = aluTemp + a + (if c then 1 else 0)
              a <- 
                  if isDecimalMode then
                      let initialAdd = (a &&& 0x0F) + (aluTemp &&& 0x0F) + (if c then 1 else 0)
                      let adjustedAdd = initialAdd + (if initialAdd > 9 then 6 else 0)
                      let result = (initialAdd &&& 0x0F) + (a &&& 0xF0) + (aluTemp &&& 0xF0) + (if adjustedAdd > 0x0F then 0x10 else 0x00)
                      z <- (binaryResult &&& 0xFF) = 0
                      n <- (result &&& 0x80) <> 0
                      c <- (result &&& 0x1FF) > 0x0F0
                      setV aluTemp result
                      result
                  else
                      NZ binaryResult
                      c <- binaryResult > 0xFF
                      setV aluTemp binaryResult
                      binaryResult
  
          let FetchDummy () =
              ReadMemory pc |> ignore
  
          let Fetch1Real () =
              if rdy then
                  branchIrqHack <- false
                  opcode <- ReadMemoryPcIncrement()
                  pc <- pc + 1
                  mi <- -1
  
          let Fetch1 () =
              myIFlag <- i
              i <- iFlagPending
              if not branchIrqHack then
                  interruptPending <- false
                  if nmi then
                      ea <- nmiVector
                      opcode <- vopNmi
                      nmi <- false
                      mi <- 0
                      ExecuteOneRetry()
                  else
                      if irq && (not myIFlag) then
                          ea <- irqVector
                          opcode <- vopIrq
                          mi <- 0
                          ExecuteOneRetry()
              else
                  Fetch1Real()
  
          let Fetch2 () =
              if rdy then
  
negative.code:             z <- (value &&& 0x02) <> 0
              c <- (value &&& 0x01) <> 0
  
          let IfReady action =
              if rdy then
                  action
              rdy
  
  
          // ----- ALU -----
  
  
          let Cmp register value =
              aluTemp <- (register - value) &&& 0xFF
              c <- register >= aluTemp
              NZ aluTemp
  
          let And value =
              aluTemp <- a &&& value
              a <- aluTemp
              NZ a
  
          let Bit value =
              aluTemp <- value
              n <- (aluTemp &&& 0x80) <> 0
              v <- (aluTemp &&& 0x40) <> 0
              z <- (a &&& aluTemp) = 0
  
          let Eor value =
              aluTemp <- a ^^^ value
              a <- aluTemp
              NZ a
  
          let Ora value =
              aluTemp <- a ||| value
              a <- aluTemp
              NZ a
  
          let Anc value =
              aluTemp <- a &&& value
              c <- (aluTemp &&& 0x80) <> 0
              a <- aluTemp
              NZ a
  
          let Asr value =
              aluTemp <- value
              let anded = a &&& aluTemp
              c <- (anded &&& 0x01) <> 0
              aluTemp <- anded >>> 1
              a <- aluTemp
              NZ a
  
          let Axs value =
              aluTemp <- value
              x <- x &&& a
              aluTemp <- (x - aluTemp)
              x <- aluTemp &&& 0xFF
              c <- (aluTemp &&& 0x100) = 0
              NZ x
  
          let Arr value =
              aluTemp <-
                  let initialMask = a &&& value
                  let binaryResult = (initialMask >>> 1) ||| (if c then 0x80 else 0x00)
                  if isDecimalMode then
                      n <- (a &&& 0x80) <> 0
  