anchor.diff:                  opcode3 <- ReadMemoryPcIncrement()
   
           let PushPch () =
  -            WriteMemoryS (pc >>> 8)
  +            pc >>> 8 |> WriteMemoryS
               DecrementS()
   
           let PushPcl () =
  
positive.code: 
          let AbsReadAnd () =
              if rdy then
                  aluTemp <- ReadMemory((opcode3 <<< 8) ||| opcode2)
                  And()
              rdy
  
          let AbsReadEor () =
              if rdy then
                  aluTemp <- ReadMemory((opcode3 <<< 8) ||| opcode2)
                  Eor()
              rdy
  
          let AbsReadOra () =
              if rdy then
                  aluTemp <- ReadMemory((opcode3 <<< 8) ||| opcode2)
                  Ora()
              rdy
  
          let AbsReadAdc () =
              if rdy then
                  aluTemp <- ReadMemory((opcode3 <<< 8) ||| opcode2)
                  Adc()
              rdy
  
          let AbsReadCmp () =
              if rdy then
                  aluTemp <- ReadMemory((opcode3 <<< 8) ||| opcode2)
                  Cmp a
              rdy
  
          let AbsReadCpy () =
              if rdy then
                  aluTemp <- ReadMemory((opcode3 <<< 8) ||| opcode2)
                  Cmp y
              rdy
  
          let AbsReadNop () =
              if rdy then
                  aluTemp <- ReadMemory((opcode3 <<< 8) ||| opcode2)
              rdy
  
          let AbsReadCpx () =
              if rdy then
                  aluTemp <- ReadMemory((opcode3 <<< 8) ||| opcode2)
                  Cmp x
              rdy
  
          let AbsReadSbc () =
              if rdy then
                  aluTemp <- ReadMemory((opcode3 <<< 8) ||| opcode2)
                  Sbc()
              rdy
  
  
          ()
  
negative.code:     let mutable c = false
  
      let rec ExecuteOneRetry () =
          let NZ value =
              z <- (value &&& 0xFF) = 0
              n <- (value &&& 0x80) <> 0
  
          let ReadMemory address =
              memory.Read(address)
  
          let WriteMemory address value =
              memory.Write(address, value)
              value
  
          let ReadMemoryPcIncrement () =
              let result = ReadMemory pc
              pc <- pc + 1
              result
  
          let ReadMemoryS () =
              ReadMemory (0x100 ||| s)
  
          let WriteMemoryS value =
              value |> WriteMemory (0x100 ||| s) |> ignore
  
          let DecrementS () =
              s <- (s - 1 &&& 0xFF)
  
          let IncrementS () =
              s <- (s + 1 &&& 0xFF)
  
          let Push value =
              value |> WriteMemoryS
              DecrementS()
  
          let Pull () =
              IncrementS()
              ReadMemoryS()
  
          let GetP () =
              0x20 |||
              (if n then 0x80 else 0x00) |||
              (if v then 0x40 else 0x00) |||
  