(*A <- (A)+ (m..m+2)*)
let add (state : Processor.state) (operand : int) : unit = 
  let valA = state.regs.a in
  state.regs.a <- valA + operand

(*F (F) + (m..m+5)*)
(*TODO check!*)
let addf (state : Processor.state) (operand : int) : unit = 
  let valF = state.regs.f in
  state.regs.f <- valF +. (float_of_int operand)

(*A <- (A) & (m..m+2)*)
let andF (state : Processor.state) (operand : int) : unit = 
  let valA = state.regs.a in
  state.regs.a <- valA land operand

(*(A):(m..m+2)*)  
let comp (state : Processor.state) (operand : int) : unit = 
  let valA = state.regs.a in
  state.regs.sw <- (if valA < operand then 0 else if valA = operand then 1 else 2)

(*A <- (A) / (m..m+2)*)
let div (state : Processor.state) (operand : int) : unit = 
  let valA = state.regs.a in
  state.regs.a <- valA / operand

(*A <- (A) * (m..m+2)*)
let mul (state : Processor.state) (operand : int) : unit = 
  let valA = state.regs.a in
  state.regs.a <- valA * operand

(*A <- (A) | (m..m+2)*)
let orF (state : Processor.state) (operand : int) : unit = 
  let valA = state.regs.a in
  state.regs.a <- valA lor operand

(*A <- (A) - (m..m+2)*)
let sub (state : Processor.state) (operand : int) : unit = 
  let valA = state.regs.a in
  state.regs.a <- valA - operand

(*PC <- m*)
let j (state : Processor.state) (operand : int) : unit = 
  state.regs.pc <- operand

(*PC <- m if CC set to =*)
let jeq (state : Processor.state) (operand : int) : unit = 
  let cc = state.regs.sw in
  match cc  with
  | 1 -> state.regs.pc <- operand
  | _ -> ()

(*PC <- m if CC set to >*)
let jgt (state : Processor.state) (operand : int) : unit = 
  let cc = state.regs.sw in
  match cc  with
  | 2 -> state.regs.pc <- operand
  | _ -> ()

(*PC <- m if CC set to <*)
let jlt (state : Processor.state) (operand : int) : unit = 
  let cc = state.regs.sw in
  match cc  with
  | 0 -> state.regs.pc <- operand
  | _ -> ()

(*L <- (PC); PC <- m*)
let jsub (state : Processor.state) (operand : int) : unit = 
  state.regs.l <- state.regs.pc;
  state.regs.pc <- operand

(*PC <- (L)*)
let rsub (state : Processor.state) : unit = 
  state.regs.pc <- state.regs.l

(*A <- (m..m+2)*)
let lda (state : Processor.state) (operand : int) : unit = 
  state.regs.a <- operand

(* LDB: B <- (m..m+2) *)
let ldb (state : Processor.state) (operand : int) : unit =
  state.regs.b <- operand

(*A [rightmost byte] ← (m)*)
(*TODO*)
let ldch (state : Processor.state) (operand : int) : unit = 
  state.regs.a <- operand

(* LDX: X <- (m..m+2) *)
let ldx (state : Processor.state) (operand : int) : unit =
  state.regs.x <- operand

(* LDL: L <- (m..m+2) *)
let ldl (state : Processor.state) (operand : int) : unit =
  state.regs.l <- operand

(* LDS: S <- (m..m+2) *)
let lds (state : Processor.state) (operand : int) : unit =
  state.regs.s <- operand

(* LDT: T <- (m..m+2) *)
let ldt (state : Processor.state) (operand : int) : unit =
  state.regs.t <- operand

(* LDF: F <- (m..m+5) *)
(*TODO*)
let ldf (state : Processor.state) (operand : float) : unit =
  state.regs.f <- operand

(*m..m+2 <- (A)*)
let sta (state : Processor.state) (operand : int) : unit = 
  let valA = state.regs.a in
  Processor.writeMemAddr state operand valA

(* m..m+2 <- (B) *)
let stb (state : Processor.state) (operand : int) : unit =
  let valB = state.regs.b in
  Processor.writeMemAddr state operand valB

(* m..m+2 <- (X) *)
let stx (state : Processor.state) (operand : int) : unit =
  let valX = state.regs.x in
  Processor.writeMemAddr state operand valX

(* m..m+2 <- (L) *)
let stl (state : Processor.state) (operand : int) : unit =
  let valL = state.regs.l in
  Processor.writeMemAddr state operand valL

(* m..m+2 <- (S) *)
let sts (state : Processor.state) (operand : int) : unit =
  let valS = state.regs.s in
  Processor.writeMemAddr state operand valS

(* m..m+2 <- (SW) *)
let stsw (state : Processor.state) (operand : int) : unit =
  let valSW = state.regs.s in
  Processor.writeMemAddr state operand valSW

(* m..m+2 <- T register *)
let stt (state : Processor.state) (operand : int) : unit =
  let valT = state.regs.t in
  Processor.writeMemAddr state operand valT

(* m..m+5 <- (F)*)
(*TODO change*)
let stf (state : Processor.state) (operand : int) : unit =
  let valF = state.regs.f in
  Processor.writeMemAddr state operand (int_of_float valF)

(*X <- (X) + 1; (X):(m..m+2)*)
let tix (state : Processor.state) (operand : int) : unit = 
  state.regs.x <- state.regs.x + 1;
  let valX = state.regs.x in
  state.regs.sw <- (if valX < operand then 0 else if valX = operand then 1 else 2)