Merge branch 'sail2' into smt_experiments

23 files changed, 2695 insertions, 380 deletions

diff --git a/lib/arith.sail b/lib/arith.sail
index 798bde12..1950080a 100644
--- a/lib/arith.sail
+++ b/lib/arith.sail
@@ -5,19 +5,19 @@ $include <flow.sail>
 
 // ***** Addition *****
 
-val add_atom = {ocaml: "add_int", lem: "integerAdd", c: "add_int", coq: "Z.add"} : forall 'n 'm.
+val add_atom = {ocaml: "add_int", interpreter: "add_int", lem: "integerAdd", c: "add_int", coq: "Z.add"} : forall 'n 'm.
   (int('n), int('m)) -> int('n + 'm)
 
-val add_int = {ocaml: "add_int", lem: "integerAdd", c: "add_int", coq: "Z.add"} : (int, int) -> int
+val add_int = {ocaml: "add_int", interpreter: "add_int", lem: "integerAdd", c: "add_int", coq: "Z.add"} : (int, int) -> int
 
 overload operator + = {add_atom, add_int}
 
 // ***** Subtraction *****
 
-val sub_atom = {ocaml: "sub_int", lem: "integerMinus", c: "sub_int", coq: "Z.sub"} : forall 'n 'm.
+val sub_atom = {ocaml: "sub_int", interpreter: "sub_int", lem: "integerMinus", c: "sub_int", coq: "Z.sub"} : forall 'n 'm.
   (int('n), int('m)) -> int('n - 'm)
 
-val sub_int = {ocaml: "sub_int", lem: "integerMinus", c: "sub_int", coq: "Z.sub"} : (int, int) -> int
+val sub_int = {ocaml: "sub_int", interpreter: "sub_int", lem: "integerMinus", c: "sub_int", coq: "Z.sub"} : (int, int) -> int
 
 overload operator - = {sub_atom, sub_int}
 
@@ -29,18 +29,18 @@ val sub_nat = {
 
 // ***** Negation *****
 
-val negate_atom = {ocaml: "negate", lem: "integerNegate", c: "neg_int", coq: "Z.opp"} : forall 'n. int('n) -> int(- 'n)
+val negate_atom = {ocaml: "negate", interpreter: "negate", lem: "integerNegate", c: "neg_int", coq: "Z.opp"} : forall 'n. int('n) -> int(- 'n)
 
-val negate_int = {ocaml: "negate", lem: "integerNegate", c: "neg_int", coq: "Z.opp"} : int -> int
+val negate_int = {ocaml: "negate", interpreter: "negate", lem: "integerNegate", c: "neg_int", coq: "Z.opp"} : int -> int
 
 overload negate = {negate_atom, negate_int}
 
 // ***** Multiplication *****
 
-val mult_atom = {ocaml: "mult", lem: "integerMult", c: "mult_int", coq: "Z.mul"} : forall 'n 'm.
+val mult_atom = {ocaml: "mult", interpreter: "mult", lem: "integerMult", c: "mult_int", coq: "Z.mul"} : forall 'n 'm.
   (int('n), int('m)) -> int('n * 'm)
 
-val mult_int = {ocaml: "mult", lem: "integerMult", c: "mult_int", coq: "Z.mul"} : (int, int) -> int
+val mult_int = {ocaml: "mult", interpreter: "mult", lem: "integerMult", c: "mult_int", coq: "Z.mul"} : (int, int) -> int
 
 overload operator * = {mult_atom, mult_int}
 
@@ -57,13 +57,13 @@ let elsize = shl_int(8, UInt(size))
 ```
 THIS ensures that in this case the typechecker knows that the end result will be a value in the set `{8, 16, 32, 64}`
 */
-val _shl8 = {c: "shl_mach_int", _: "shl_int"} :
+val _shl8 = {c: "shl_mach_int", coq: "shl_int_8", _: "shl_int"} :
   forall 'n, 0 <= 'n <= 3. (int(8), int('n)) -> {'m, 'm in {8, 16, 32, 64}. int('m)}
 
 /*!
 Similarly, we can shift 32 by either 0 or 1 to get a value in `{32, 64}`
 */
-val _shl32 = {c: "shl_mach_int", _: "shl_int"} :
+val _shl32 = {c: "shl_mach_int", coq: "shl_int_32", _: "shl_int"} :
   forall 'n, 'n in {0, 1}. (int(32), int('n)) -> {'m, 'm in {32, 64}. int('m)}
 
 val _shl_int = "shl_int" : (int, int) -> int
@@ -81,20 +81,25 @@ overload shr_int = {_shr32, _shr_int}
 /*! Truncating division (rounds towards zero) */
 val tdiv_int = {
   ocaml: "tdiv_int",
+  interpreter: "tdiv_int",
   lem: "integerDiv_t",
-  c: "tdiv_int"
+  c: "tdiv_int",
+  coq: "Z.quot"
 } : (int, int) -> int
 
 /*! Remainder for truncating division (has sign of dividend) */
 val tmod_int = {
   ocaml: "tmod_int",
+  interpreter: "tmod_int",
   lem: "integerMod_t",
-  c: "tmod_int"
+  c: "tmod_int",
+  coq: "Z.rem"
 } : (int, int) -> nat
 
 val abs_int = {
   smt : "abs",
   ocaml: "abs_int",
+  interpreter: "abs_int",
   lem: "abs_int",
   c: "abs_int",
   coq: "Z.abs"
diff --git a/lib/coq/Makefile b/lib/coq/Makefile
index 6dd962d1..f763db6f 100644
--- a/lib/coq/Makefile
+++ b/lib/coq/Makefile
@@ -1,6 +1,6 @@
 BBV_DIR?=../../../bbv
 
-SRC=Sail2_prompt_monad.v  Sail2_prompt.v  Sail2_impl_base.v  Sail2_instr_kinds.v  Sail2_operators_bitlists.v  Sail2_operators_mwords.v  Sail2_operators.v  Sail2_values.v  Sail2_state_monad.v  Sail2_state.v  Sail2_string.v  Sail2_real.v
+SRC=Sail2_prompt_monad.v  Sail2_prompt.v  Sail2_impl_base.v  Sail2_instr_kinds.v  Sail2_operators_bitlists.v  Sail2_operators_mwords.v  Sail2_operators.v  Sail2_values.v  Sail2_state_monad.v  Sail2_state.v  Sail2_state_lifting.v  Sail2_string.v  Sail2_real.v
 
 COQ_LIBS = -R . Sail -R "$(BBV_DIR)/theories" bbv
 
diff --git a/lib/coq/Sail2_instr_kinds.v b/lib/coq/Sail2_instr_kinds.v
index c6fb866b..338bf10b 100644
--- a/lib/coq/Sail2_instr_kinds.v
+++ b/lib/coq/Sail2_instr_kinds.v
@@ -48,14 +48,13 @@
 (*  SUCH DAMAGE.                                                          *)
 (*========================================================================*)
 
+Require Import DecidableClass.
 
-(*
-
-class ( EnumerationType 'a )
-  val toNat : 'a -> nat
-end
-
+Class EnumerationType (A : Type) := {
+  toNat : A -> nat
+}.
 
+(*
 val enumeration_typeCompare : forall 'a. EnumerationType 'a => 'a -> 'a -> ordering
 let ~{ocaml} enumeration_typeCompare e1 e2 :=
   compare (toNat e1) (toNat e2)
@@ -89,6 +88,7 @@ Inductive read_kind :=
   (* x86 reads *)
   | Read_X86_locked (* the read part of a lock'd instruction (rmw) *)
 .
+Scheme Equality for read_kind.
 (*
 instance (Show read_kind)
   let show := function
@@ -121,6 +121,7 @@ Inductive write_kind :=
   (* x86 writes *)
   | Write_X86_locked (* the write part of a lock'd instruction (rmw) *)
 .
+Scheme Equality for write_kind.
 (*
 instance (Show write_kind)
   let show := function
@@ -161,6 +162,7 @@ Inductive barrier_kind :=
   | Barrier_RISCV_i
   (* X86 *)
   | Barrier_x86_MFENCE.
+Scheme Equality for barrier_kind.
 
 (*
 instance (Show barrier_kind)
@@ -196,6 +198,7 @@ end*)
 Inductive trans_kind :=
   (* AArch64 *)
   | Transaction_start | Transaction_commit | Transaction_abort.
+Scheme Equality for trans_kind.
 (*
 instance (Show trans_kind)
   let show := function
diff --git a/lib/coq/Sail2_operators_mwords.v b/lib/coq/Sail2_operators_mwords.v
index ebab269f..5a5f130c 100644
--- a/lib/coq/Sail2_operators_mwords.v
+++ b/lib/coq/Sail2_operators_mwords.v
@@ -485,7 +485,7 @@ Definition reverse_endianness {n} (bits : mword n) := with_word (P := id) revers
 Definition get_slice_int {a} `{ArithFact (a >= 0)} : Z -> Z -> Z -> mword a := get_slice_int_bv.
 
 Definition set_slice n m (v : mword n) x (w : mword m) : mword n :=
-  update_subrange_vec_dec v (x + m - 1) x v.
+  update_subrange_vec_dec v (x + m - 1) x w.
 
 Definition set_slice_int len n lo (v : mword len) : Z :=
   let hi := lo + len - 1 in
diff --git a/lib/coq/Sail2_prompt.v b/lib/coq/Sail2_prompt.v
index 8efd66f0..5ab93cbc 100644
--- a/lib/coq/Sail2_prompt.v
+++ b/lib/coq/Sail2_prompt.v
@@ -136,19 +136,29 @@ Definition Zwf_guarded (z:Z) : Acc (Zwf 0) z :=
   end).
 
 (*val whileM : forall 'rv 'vars 'e. 'vars -> ('vars -> monad 'rv bool 'e) ->
-                ('vars -> monad 'rv 'vars 'e) -> monad 'rv 'vars 'e
-let rec whileM vars cond body =
-  cond vars >>= fun cond_val ->
-  if cond_val then
-    body vars >>= fun vars -> whileM vars cond body
-  else return vars
-
-val untilM : forall 'rv 'vars 'e. 'vars -> ('vars -> monad 'rv bool 'e) ->
-                ('vars -> monad 'rv 'vars 'e) -> monad 'rv 'vars 'e
-let rec untilM vars cond body =
-  body vars >>= fun vars ->
-  cond vars >>= fun cond_val ->
-  if cond_val then return vars else untilM vars cond body
+                ('vars -> monad 'rv 'vars 'e) -> monad 'rv 'vars 'e*)
+Fixpoint whileMT' {RV Vars E} limit (vars : Vars) (cond : Vars -> monad RV bool E) (body : Vars -> monad RV Vars E) (acc : Acc (Zwf 0) limit) : monad RV Vars E :=
+  if Z_ge_dec limit 0 then
+    cond vars >>= fun cond_val =>
+    if cond_val then
+      body vars >>= fun vars => whileMT' (limit - 1) vars cond body (_limit_reduces acc)
+    else returnm vars
+  else Fail "Termination limit reached".
+
+Definition whileMT {RV Vars E} limit (vars : Vars) (cond : Vars -> monad RV bool E) (body : Vars -> monad RV Vars E) : monad RV Vars E :=
+  whileMT' limit vars cond body (Zwf_guarded limit).
+
+(*val untilM : forall 'rv 'vars 'e. 'vars -> ('vars -> monad 'rv bool 'e) ->
+                ('vars -> monad 'rv 'vars 'e) -> monad 'rv 'vars 'e*)
+Fixpoint untilMT' {RV Vars E} limit (vars : Vars) (cond : Vars -> monad RV bool E) (body : Vars -> monad RV Vars E) (acc : Acc (Zwf 0) limit) : monad RV Vars E :=
+  if Z_ge_dec limit 0 then
+    body vars >>= fun vars =>
+    cond vars >>= fun cond_val =>
+    if cond_val then returnm vars else untilMT' (limit - 1) vars cond body (_limit_reduces acc)
+  else Fail "Termination limit reached".
+
+Definition untilMT {RV Vars E} limit (vars : Vars) (cond : Vars -> monad RV bool E) (body : Vars -> monad RV Vars E) : monad RV Vars E :=
+  untilMT' limit vars cond body (Zwf_guarded limit).
 
 (*let write_two_regs r1 r2 vec =
   let is_inc =
@@ -171,8 +181,6 @@ let rec untilM vars cond body =
     else slice vec (start_vec - size_r1) (start_vec - size_vec) in
   write_reg r1 r1_v >> write_reg r2 r2_v*)
 
-*)
-
 (* If we need to build an existential after a monadic operation, assume that
    we can do it entirely from the type. *)
 
diff --git a/lib/coq/Sail2_prompt_monad.v b/lib/coq/Sail2_prompt_monad.v
index 2715b5e7..f95e4b6c 100644
--- a/lib/coq/Sail2_prompt_monad.v
+++ b/lib/coq/Sail2_prompt_monad.v
@@ -2,27 +2,28 @@ Require Import String.
 (*Require Import Sail_impl_base*)
 Require Import Sail2_instr_kinds.
 Require Import Sail2_values.
-
-
+Require bbv.Word.
+Import ListNotations.
 
 Definition register_name := string.
 Definition address := list bitU.
 
 Inductive monad regval a e :=
   | Done : a -> monad regval a e
-  (* Read a number : bytes from memory, returned in little endian order *)
-  | Read_mem : read_kind -> address -> nat -> (list memory_byte -> monad regval a e) -> monad regval a e
-  (* Read the tag : a memory address *)
-  | Read_tag : address -> (bitU -> monad regval a e) -> monad regval a e
-  (* Tell the system a write is imminent, at address lifted, : size nat *)
-  | Write_ea : write_kind -> address -> nat -> monad regval a e -> monad regval a e
+  (* Read a number of bytes from memory, returned in little endian order,
+     with or without a tag.  The first nat specifies the address, the second
+     the number of bytes. *)
+  | Read_mem : read_kind -> nat -> nat -> (list memory_byte -> monad regval a e) -> monad regval a e
+  | Read_memt : read_kind -> nat -> nat -> ((list memory_byte * bitU) -> monad regval a e) -> monad regval a e
+  (* Tell the system a write is imminent, at the given address and with the
+     given size. *)
+  | Write_ea : write_kind -> nat -> nat -> monad regval a e -> monad regval a e
   (* Request the result : store-exclusive *)
   | Excl_res : (bool -> monad regval a e) -> monad regval a e
-  (* Request to write memory at last signalled address. Memory value should be 8
-     times the size given in ea signal, given in little endian order *)
-  | Write_memv : list memory_byte -> (bool -> monad regval a e) -> monad regval a e
-  (* Request to write the tag at last signalled address. *)
-  | Write_tag : address -> bitU -> (bool -> monad regval a e) -> monad regval a e
+  (* Request to write a memory value of the given size at the given address,
+     with or without a tag. *)
+  | Write_mem : write_kind -> nat -> nat -> list memory_byte -> (bool -> monad regval a e) -> monad regval a e
+  | Write_memt : write_kind -> nat -> nat -> list memory_byte -> bitU -> (bool -> monad regval a e) -> monad regval a e
   (* Tell the system to dynamically recalculate dependency footprint *)
   | Footprint : monad regval a e -> monad regval a e
   (* Request a memory barrier *)
@@ -31,50 +32,70 @@ Inductive monad regval a e :=
   | Read_reg : register_name -> (regval -> monad regval a e) -> monad regval a e
   (* Request to write register *)
   | Write_reg : register_name -> regval -> monad regval a e -> monad regval a e
-  | Undefined : (bool -> monad regval a e) -> monad regval a e
-  (*Result : a failed assert with possible error message to report*)
+  (* Request to choose a Boolean, e.g. to resolve an undefined bit. The string
+     argument may be used to provide information to the system about what the
+     Boolean is going to be used for. *)
+  | Choose : string -> (bool -> monad regval a e) -> monad regval a e
+  (* Print debugging or tracing information *)
+  | Print : string -> monad regval a e -> monad regval a e
+  (*Result of a failed assert with possible error message to report*)
   | Fail : string -> monad regval a e
-  | Error : string -> monad regval a e
-  (* Exception : type e *)
+  (* Exception of type e *)
   | Exception : e -> monad regval a e.
-  (* TODO: Reading/writing tags *)
 
 Arguments Done [_ _ _].
 Arguments Read_mem [_ _ _].
-Arguments Read_tag [_ _ _].
+Arguments Read_memt [_ _ _].
 Arguments Write_ea [_ _ _].
 Arguments Excl_res [_ _ _].
-Arguments Write_memv [_ _ _].
-Arguments Write_tag [_ _ _].
+Arguments Write_mem [_ _ _].
+Arguments Write_memt [_ _ _].
 Arguments Footprint [_ _ _].
 Arguments Barrier [_ _ _].
 Arguments Read_reg [_ _ _].
 Arguments Write_reg [_ _ _].
-Arguments Undefined [_ _ _].
+Arguments Choose [_ _ _].
+Arguments Print [_ _ _].
 Arguments Fail [_ _ _].
-Arguments Error [_ _ _].
 Arguments Exception [_ _ _].
 
+Inductive event {regval} :=
+  | E_read_mem : read_kind -> nat -> nat -> list memory_byte -> event
+  | E_read_memt : read_kind -> nat -> nat -> (list memory_byte * bitU) -> event
+  | E_write_mem : write_kind -> nat -> nat -> list memory_byte -> bool -> event
+  | E_write_memt : write_kind -> nat -> nat -> list memory_byte -> bitU -> bool -> event
+  | E_write_ea : write_kind -> nat -> nat -> event
+  | E_excl_res : bool -> event
+  | E_barrier : barrier_kind -> event
+  | E_footprint : event
+  | E_read_reg : register_name -> regval -> event
+  | E_write_reg : register_name -> regval -> event
+  | E_choose : string -> bool -> event
+  | E_print : string -> event.
+Arguments event : clear implicits.
+
+Definition trace regval := list (event regval).
+
 (*val return : forall rv a e. a -> monad rv a e*)
 Definition returnm {rv A E} (a : A) : monad rv A E := Done a.
 
 (*val bind : forall rv a b e. monad rv a e -> (a -> monad rv b e) -> monad rv b e*)
 Fixpoint bind {rv A B E} (m : monad rv A E) (f : A -> monad rv B E) := match m with
   | Done a => f a
-  | Read_mem rk a sz k => Read_mem rk a sz (fun v => bind (k v) f)
-  | Read_tag a k =>       Read_tag a       (fun v => bind (k v) f)
-  | Write_memv descr k => Write_memv descr (fun v => bind (k v) f)
-  | Write_tag a t k =>    Write_tag a t    (fun v => bind (k v) f)
-  | Read_reg descr k =>   Read_reg descr   (fun v => bind (k v) f)
-  | Excl_res k =>         Excl_res         (fun v => bind (k v) f)
-  | Undefined k =>        Undefined        (fun v => bind (k v) f)
-  | Write_ea wk a sz k => Write_ea wk a sz (bind k f)
-  | Footprint k =>        Footprint        (bind k f)
-  | Barrier bk k =>       Barrier bk       (bind k f)
-  | Write_reg r v k =>    Write_reg r v    (bind k f)
-  | Fail descr =>         Fail descr
-  | Error descr =>        Error descr
-  | Exception e =>        Exception e
+  | Read_mem rk a sz k =>       Read_mem rk a sz       (fun v => bind (k v) f)
+  | Read_memt rk a sz k =>      Read_memt rk a sz      (fun v => bind (k v) f)
+  | Write_mem wk a sz v k =>    Write_mem wk a sz v    (fun v => bind (k v) f)
+  | Write_memt wk a sz v t k => Write_memt wk a sz v t (fun v => bind (k v) f)
+  | Read_reg descr k =>         Read_reg descr         (fun v => bind (k v) f)
+  | Excl_res k =>               Excl_res               (fun v => bind (k v) f)
+  | Choose descr k =>           Choose descr           (fun v => bind (k v) f)
+  | Write_ea wk a sz k =>       Write_ea wk a sz       (bind k f)
+  | Footprint k =>              Footprint              (bind k f)
+  | Barrier bk k =>             Barrier bk             (bind k f)
+  | Write_reg r v k =>          Write_reg r v          (bind k f)
+  | Print msg k =>              Print msg              (bind k f)
+  | Fail descr =>               Fail descr
+  | Exception e =>              Exception e
 end.
 
 Notation "m >>= f" := (bind m f) (at level 50, left associativity).
@@ -86,8 +107,11 @@ Notation "m >> n" := (bind0 m n) (at level 50, left associativity).
 (*val exit : forall rv a e. unit -> monad rv a e*)
 Definition exit {rv A E} (_ : unit) : monad rv A E := Fail "exit".
 
+(*val choose_bool : forall 'rv 'e. string -> monad 'rv bool 'e*)
+Definition choose_bool {rv E} descr : monad rv bool E := Choose descr returnm.
+
 (*val undefined_bool : forall 'rv 'e. unit -> monad 'rv bool 'e*)
-Definition undefined_bool {rv e} (_:unit) : monad rv bool e := Undefined returnm.
+Definition undefined_bool {rv e} (_:unit) : monad rv bool e := choose_bool "undefined_bool".
 
 (*val assert_exp : forall rv e. bool -> string -> monad rv unit e*)
 Definition assert_exp {rv E} (exp :bool) msg : monad rv unit E :=
@@ -104,21 +128,21 @@ Definition throw {rv A E} e : monad rv A E := Exception e.
 
 (*val try_catch : forall rv a e1 e2. monad rv a e1 -> (e1 -> monad rv a e2) -> monad rv a e2*)
 Fixpoint try_catch {rv A E1 E2} (m : monad rv A E1) (h : E1 -> monad rv A E2) := match m with
-  | Done a =>             Done a
-  | Read_mem rk a sz k => Read_mem rk a sz (fun v => try_catch (k v) h)
-  | Read_tag a k =>       Read_tag a       (fun v => try_catch (k v) h)
-  | Write_memv descr k => Write_memv descr (fun v => try_catch (k v) h)
-  | Write_tag a t k =>    Write_tag a t     (fun v => try_catch (k v) h)
-  | Read_reg descr k =>   Read_reg descr   (fun v => try_catch (k v) h)
-  | Excl_res k =>         Excl_res         (fun v => try_catch (k v) h)
-  | Undefined k =>        Undefined        (fun v => try_catch (k v) h)
-  | Write_ea wk a sz k => Write_ea wk a sz (try_catch k h)
-  | Footprint k =>        Footprint        (try_catch k h)
-  | Barrier bk k =>       Barrier bk       (try_catch k h)
-  | Write_reg r v k =>    Write_reg r v    (try_catch k h)
-  | Fail descr =>         Fail descr
-  | Error descr =>        Error descr
-  | Exception e =>        h e
+  | Done a =>                   Done a
+  | Read_mem rk a sz k =>       Read_mem rk a sz       (fun v => try_catch (k v) h)
+  | Read_memt rk a sz k =>      Read_memt rk a sz      (fun v => try_catch (k v) h)
+  | Write_mem wk a sz v k =>    Write_mem wk a sz v    (fun v => try_catch (k v) h)
+  | Write_memt wk a sz v t k => Write_memt wk a sz v t (fun v => try_catch (k v) h)
+  | Read_reg descr k =>         Read_reg descr         (fun v => try_catch (k v) h)
+  | Excl_res k =>               Excl_res               (fun v => try_catch (k v) h)
+  | Choose descr k =>           Choose descr           (fun v => try_catch (k v) h)
+  | Write_ea wk a sz k =>       Write_ea wk a sz       (try_catch k h)
+  | Footprint k =>              Footprint              (try_catch k h)
+  | Barrier bk k =>             Barrier bk             (try_catch k h)
+  | Write_reg r v k =>          Write_reg r v          (try_catch k h)
+  | Print msg k =>              Print msg              (try_catch k h)
+  | Fail descr =>               Fail descr
+  | Exception e =>              h e
 end.
 
 (* For early return, we abuse exceptions by throwing and catching
@@ -158,61 +182,81 @@ match x with
   | None => Fail msg
 end.
 
+(*val read_memt_bytes : forall 'rv 'a 'b 'e. Bitvector 'a, Bitvector 'b => read_kind -> 'a -> integer -> monad 'rv (list memory_byte * bitU) 'e*)
+Definition read_memt_bytes {rv A E} rk (addr : mword A) sz : monad rv (list memory_byte * bitU) E :=
+  Read_memt rk (Word.wordToNat (get_word addr)) (Z.to_nat sz) returnm.
+
+(*val read_memt : forall 'rv 'a 'b 'e. Bitvector 'a, Bitvector 'b => read_kind -> 'a -> integer -> monad 'rv ('b * bitU) 'e*)
+Definition read_memt {rv A B E} `{ArithFact (B >= 0)} rk (addr : mword A) sz : monad rv (mword B * bitU) E :=
+  bind
+    (read_memt_bytes rk addr sz)
+    (fun '(bytes, tag) =>
+       match of_bits (bits_of_mem_bytes bytes) with
+       | Some v => returnm (v, tag)
+       | None => Fail "bits_of_mem_bytes"
+       end).
+
 (*val read_mem_bytes : forall 'rv 'a 'b 'e. Bitvector 'a, Bitvector 'b => read_kind -> 'a -> integer -> monad 'rv (list memory_byte) 'e*)
 Definition read_mem_bytes {rv A E} rk (addr : mword A) sz : monad rv (list memory_byte) E :=
-  Read_mem rk (bits_of addr) (Z.to_nat sz) returnm.
+  Read_mem rk (Word.wordToNat (get_word addr)) (Z.to_nat sz) returnm.
 
 (*val read_mem : forall 'rv 'a 'b 'e. Bitvector 'a, Bitvector 'b => read_kind -> 'a -> integer -> monad 'rv 'b 'e*)
-Definition read_mem {rv A B E} `{ArithFact (B >= 0)} rk (addr : mword A) sz : monad rv (mword B) E :=
+Definition read_mem {rv A B E} `{ArithFact (B >= 0)} rk (addrsz : Z) (addr : mword A) sz : monad rv (mword B) E :=
   bind
     (read_mem_bytes rk addr sz)
     (fun bytes =>
        maybe_fail "bits_of_mem_bytes" (of_bits (bits_of_mem_bytes bytes))).
 
-(*val read_tag : forall rv a e. Bitvector a => a -> monad rv bitU e*)
-Definition read_tag {rv a e} `{Bitvector a} (addr : a) : monad rv bitU e :=
- Read_tag (bits_of addr) returnm.
-
 (*val excl_result : forall rv e. unit -> monad rv bool e*)
 Definition excl_result {rv e} (_:unit) : monad rv bool e :=
   let k successful := (returnm successful) in
   Excl_res k.
 
-Definition write_mem_ea {rv a E} `{Bitvector a} wk (addr: a) sz : monad rv unit E :=
- Write_ea wk (bits_of addr) (Z.to_nat sz) (Done tt).
-
-Definition write_mem_val {rv a e} `{Bitvector a} (v : a) : monad rv bool e := match mem_bytes_of_bits v with
-  | Some v => Write_memv v returnm
-  | None => Fail "write_mem_val"
-end.
-
-(*val write_tag : forall rv a e. Bitvector 'a => 'a -> bitU -> monad rv bool e*)
-Definition write_tag {rv a e} (addr : mword a) (b : bitU) : monad rv bool e := Write_tag (bits_of addr) b returnm.
+Definition write_mem_ea {rv a E} wk (addrsz : Z) (addr: mword a) sz : monad rv unit E :=
+ Write_ea wk (Word.wordToNat (get_word addr)) (Z.to_nat sz) (Done tt).
+
+(*val write_mem : forall 'rv 'a 'b 'e. Bitvector 'a, Bitvector 'b =>
+  write_kind -> integer -> 'a -> integer -> 'b -> monad 'rv bool 'e*)
+Definition write_mem {rv a b E} wk (addrsz : Z) (addr : mword a) sz (v : mword b) : monad rv bool E :=
+  match (mem_bytes_of_bits v, Word.wordToNat (get_word addr)) with
+    | (Some v, addr) =>
+       Write_mem wk addr (Z.to_nat sz) v returnm
+    | _ => Fail "write_mem"
+  end.
+
+(*val write_memt : forall 'rv 'a 'b 'e. Bitvector 'a, Bitvector 'b =>
+  write_kind -> 'a -> integer -> 'b -> bitU -> monad 'rv bool 'e*)
+Definition write_memt {rv a b E} wk (addr : mword a) sz (v : mword b) tag : monad rv bool E :=
+  match (mem_bytes_of_bits v, Word.wordToNat (get_word addr)) with
+    | (Some v, addr) =>
+       Write_memt wk addr (Z.to_nat sz) v tag returnm
+    | _ => Fail "write_mem"
+  end.
 
 Definition read_reg {s rv a e} (reg : register_ref s rv a) : monad rv a e :=
   let k v :=
     match reg.(of_regval) v with
       | Some v => Done v
-      | None => Error "read_reg: unrecognised value"
+      | None => Fail "read_reg: unrecognised value"
     end
   in
   Read_reg reg.(name) k.
 
 (* TODO
-val read_reg_range : forall s r rv a e. Bitvector a => register_ref s rv r -> integer -> integer -> monad rv a e
-Definition read_reg_range reg i j :=
-  read_reg_aux of_bits (external_reg_slice reg (natFromInteger i,natFromInteger j))
+val read_reg_range : forall 's 'r 'rv 'a 'e. Bitvector 'a => register_ref 's 'rv 'r -> integer -> integer -> monad 'rv 'a 'e
+let read_reg_range reg i j =
+  read_reg_aux of_bits (external_reg_slice reg (nat_of_int i,nat_of_int j))
 
-Definition read_reg_bit reg i :=
-  read_reg_aux (fun v -> v) (external_reg_slice reg (natFromInteger i,natFromInteger i)) >>= fun v ->
-  returnm (extract_only_element v)
+let read_reg_bit reg i =
+  read_reg_aux (fun v -> v) (external_reg_slice reg (nat_of_int i,nat_of_int i)) >>= fun v ->
+  return (extract_only_element v)
 
-Definition read_reg_field reg regfield :=
+let read_reg_field reg regfield =
   read_reg_aux (external_reg_field_whole reg regfield)
 
-Definition read_reg_bitfield reg regfield :=
+let read_reg_bitfield reg regfield =
   read_reg_aux (external_reg_field_whole reg regfield) >>= fun v ->
-  returnm (extract_only_element v)*)
+  return (extract_only_element v)*)
 
 Definition reg_deref {s rv a e} := @read_reg s rv a e.
 
@@ -221,27 +265,101 @@ Definition write_reg {s rv a e} (reg : register_ref s rv a) (v : a) : monad rv u
  Write_reg reg.(name) (reg.(regval_of) v) (Done tt).
 
 (* TODO
-Definition write_reg reg v :=
+let write_reg reg v =
   write_reg_aux (external_reg_whole reg) v
-Definition write_reg_range reg i j v :=
-  write_reg_aux (external_reg_slice reg (natFromInteger i,natFromInteger j)) v
-Definition write_reg_pos reg i v :=
-  let iN := natFromInteger i in
+let write_reg_range reg i j v =
+  write_reg_aux (external_reg_slice reg (nat_of_int i,nat_of_int j)) v
+let write_reg_pos reg i v =
+  let iN = nat_of_int i in
   write_reg_aux (external_reg_slice reg (iN,iN)) [v]
-Definition write_reg_bit := write_reg_pos
-Definition write_reg_field reg regfield v :=
+let write_reg_bit = write_reg_pos
+let write_reg_field reg regfield v =
   write_reg_aux (external_reg_field_whole reg regfield.field_name) v
-Definition write_reg_field_bit reg regfield bit :=
+let write_reg_field_bit reg regfield bit =
   write_reg_aux (external_reg_field_whole reg regfield.field_name)
                 (Vector [bit] 0 (is_inc_of_reg reg))
-Definition write_reg_field_range reg regfield i j v :=
-  write_reg_aux (external_reg_field_slice reg regfield.field_name (natFromInteger i,natFromInteger j)) v
-Definition write_reg_field_pos reg regfield i v :=
+let write_reg_field_range reg regfield i j v =
+  write_reg_aux (external_reg_field_slice reg regfield.field_name (nat_of_int i,nat_of_int j)) v
+let write_reg_field_pos reg regfield i v =
   write_reg_field_range reg regfield i i [v]
-Definition write_reg_field_bit := write_reg_field_pos*)
+let write_reg_field_bit = write_reg_field_pos*)
 
 (*val barrier : forall rv e. barrier_kind -> monad rv unit e*)
 Definition barrier {rv e} bk : monad rv unit e := Barrier bk (Done tt).
 
 (*val footprint : forall rv e. unit -> monad rv unit e*)
 Definition footprint {rv e} (_ : unit) : monad rv unit e := Footprint (Done tt).
+
+(* Event traces *)
+
+Local Open Scope bool_scope.
+
+(*val emitEvent : forall 'regval 'a 'e. Eq 'regval => monad 'regval 'a 'e -> event 'regval -> maybe (monad 'regval 'a 'e)*)
+Definition emitEvent {Regval A E} `{forall (x y : Regval), Decidable (x = y)} (m : monad Regval A E) (e : event Regval) : option (monad Regval A E) :=
+ match (e, m) with
+  | (E_read_mem rk a sz v, Read_mem rk' a' sz' k) =>
+     if read_kind_beq rk' rk && Nat.eqb a' a && Nat.eqb sz' sz then Some (k v) else None
+  | (E_read_memt rk a sz vt, Read_memt rk' a' sz' k) =>
+     if read_kind_beq rk' rk && Nat.eqb a' a && Nat.eqb sz' sz then Some (k vt) else None
+  | (E_write_mem wk a sz v r, Write_mem wk' a' sz' v' k) =>
+     if write_kind_beq wk' wk && Nat.eqb a' a && Nat.eqb sz' sz && generic_eq v' v then Some (k r) else None
+  | (E_write_memt wk a sz v tag r, Write_memt wk' a' sz' v' tag' k) =>
+     if write_kind_beq wk' wk && Nat.eqb a' a && Nat.eqb sz' sz && generic_eq v' v && generic_eq tag' tag then Some (k r) else None
+  | (E_read_reg r v, Read_reg r' k) =>
+     if generic_eq r' r then Some (k v) else None
+  | (E_write_reg r v, Write_reg r' v' k) =>
+     if generic_eq r' r && generic_eq v' v then Some k else None
+  | (E_write_ea wk a sz, Write_ea wk' a' sz' k) =>
+     if write_kind_beq wk' wk && Nat.eqb a' a && Nat.eqb sz' sz then Some k else None
+  | (E_barrier bk, Barrier bk' k) =>
+     if barrier_kind_beq bk' bk then Some k else None
+  | (E_print m, Print m' k) =>
+     if generic_eq m' m then Some k else None
+  | (E_excl_res v, Excl_res k) => Some (k v)
+  | (E_choose descr v, Choose descr' k) => if generic_eq descr' descr then Some (k v) else None
+  | (E_footprint, Footprint k) => Some k
+  | _ => None
+end.
+
+Definition option_bind {A B : Type} (a : option A) (f : A -> option B) : option B :=
+match a with
+| Some x => f x
+| None => None
+end.
+
+(*val runTrace : forall 'regval 'a 'e. Eq 'regval => trace 'regval -> monad 'regval 'a 'e -> maybe (monad 'regval 'a 'e)*)
+Fixpoint runTrace {Regval A E} `{forall (x y : Regval), Decidable (x = y)} (t : trace Regval) (m : monad Regval A E) : option (monad Regval A E) :=
+match t with
+  | [] => Some m
+  | e :: t' => option_bind (emitEvent m e) (runTrace t')
+end.
+
+(*val final : forall 'regval 'a 'e. monad 'regval 'a 'e -> bool*)
+Definition final {Regval A E} (m : monad Regval A E) : bool :=
+match m with
+  | Done _ => true
+  | Fail _ => true
+  | Exception _ => true
+  | _ => false
+end.
+
+(*val hasTrace : forall 'regval 'a 'e. Eq 'regval => trace 'regval -> monad 'regval 'a 'e -> bool*)
+Definition hasTrace {Regval A E} `{forall (x y : Regval), Decidable (x = y)} (t : trace Regval) (m : monad Regval A E) : bool :=
+match runTrace t m with
+  | Some m => final m
+  | None => false
+end.
+
+(*val hasException : forall 'regval 'a 'e. Eq 'regval => trace 'regval -> monad 'regval 'a 'e -> bool*)
+Definition hasException {Regval A E} `{forall (x y : Regval), Decidable (x = y)} (t : trace Regval) (m : monad Regval A E) :=
+match runTrace t m with
+  | Some (Exception _) => true
+  | _ => false
+end.
+
+(*val hasFailure : forall 'regval 'a 'e. Eq 'regval => trace 'regval -> monad 'regval 'a 'e -> bool*)
+Definition hasFailure {Regval A E} `{forall (x y : Regval), Decidable (x = y)} (t : trace Regval) (m : monad Regval A E) :=
+match runTrace t m with
+  | Some (Fail _) => true
+  | _ => false
+end.
diff --git a/lib/coq/Sail2_state.v b/lib/coq/Sail2_state.v
index 1d5cb342..b73d5013 100644
--- a/lib/coq/Sail2_state.v
+++ b/lib/coq/Sail2_state.v
@@ -3,53 +3,82 @@ Require Import Sail2_values.
 Require Import Sail2_prompt_monad.
 Require Import Sail2_prompt.
 Require Import Sail2_state_monad.
-(*
-(* State monad wrapper around prompt monad *)
-
-val liftState : forall 'regval 'regs 'a 'e. register_accessors 'regs 'regval -> monad 'regval 'a 'e -> monadS 'regs 'a 'e
-let rec liftState ra s = match s with
-  | (Done a)             -> returnS a
-  | (Read_mem rk a sz k) -> bindS (read_mem_bytesS rk a sz) (fun v -> liftState ra (k v))
-  | (Read_tag t k)       -> bindS (read_tagS t)             (fun v -> liftState ra (k v))
-  | (Write_memv a k)     -> bindS (write_mem_bytesS a)      (fun v -> liftState ra (k v))
-  | (Write_tagv t k)     -> bindS (write_tagS t)            (fun v -> liftState ra (k v))
-  | (Read_reg r k)       -> bindS (read_regvalS ra r)       (fun v -> liftState ra (k v))
-  | (Excl_res k)         -> bindS (excl_resultS ())         (fun v -> liftState ra (k v))
-  | (Undefined k)        -> bindS (undefined_boolS ())      (fun v -> liftState ra (k v))
-  | (Write_ea wk a sz k) -> seqS (write_mem_eaS wk a sz)    (liftState ra k)
-  | (Write_reg r v k)    -> seqS (write_regvalS ra r v)     (liftState ra k)
-  | (Footprint k)        -> liftState ra k
-  | (Barrier _ k)        -> liftState ra k
-  | (Fail descr)         -> failS descr
-  | (Error descr)        -> failS descr
-  | (Exception e)        -> throwS e
-end
-
-
-val iterS_aux : forall 'rv 'a 'e. integer -> (integer -> 'a -> monadS 'rv unit 'e) -> list 'a -> monadS 'rv unit 'e
-let rec iterS_aux i f xs = match xs with
-  | x :: xs -> f i x >>$ iterS_aux (i + 1) f xs
-  | [] -> returnS ()
-  end
+Import ListNotations.
 
-declare {isabelle} termination_argument iterS_aux = automatic
+(*val iterS_aux : forall 'rv 'a 'e. integer -> (integer -> 'a -> monadS 'rv unit 'e) -> list 'a -> monadS 'rv unit 'e*)
+Fixpoint iterS_aux {RV A E} i (f : Z -> A -> monadS RV unit E) (xs : list A) :=
+ match xs with
+  | x :: xs => f i x >>$ iterS_aux (i + 1) f xs
+  | [] => returnS tt
+  end.
 
-val iteriS : forall 'rv 'a 'e. (integer -> 'a -> monadS 'rv unit 'e) -> list 'a -> monadS 'rv unit 'e
-let iteriS f xs = iterS_aux 0 f xs
+(*val iteriS : forall 'rv 'a 'e. (integer -> 'a -> monadS 'rv unit 'e) -> list 'a -> monadS 'rv unit 'e*)
+Definition iteriS {RV A E} (f : Z -> A -> monadS RV unit E) (xs : list A) : monadS RV unit E :=
+ iterS_aux 0 f xs.
 
-val iterS : forall 'rv 'a 'e. ('a -> monadS 'rv unit 'e) -> list 'a -> monadS 'rv unit 'e
-let iterS f xs = iteriS (fun _ x -> f x) xs
+(*val iterS : forall 'rv 'a 'e. ('a -> monadS 'rv unit 'e) -> list 'a -> monadS 'rv unit 'e*)
+Definition iterS {RV A E} (f : A -> monadS RV unit E) (xs : list A) : monadS RV unit E :=
+ iteriS (fun _ x => f x) xs.
 
-val foreachS : forall 'a 'rv 'vars 'e.
-  list 'a -> 'vars -> ('a -> 'vars -> monadS 'rv 'vars 'e) -> monadS 'rv 'vars 'e
-let rec foreachS xs vars body = match xs with
-  | [] -> returnS vars
-  | x :: xs ->
-     body x vars >>$= fun vars ->
+(*val foreachS : forall 'a 'rv 'vars 'e.
+  list 'a -> 'vars -> ('a -> 'vars -> monadS 'rv 'vars 'e) -> monadS 'rv 'vars 'e*)
+Fixpoint foreachS {A RV Vars E} (xs : list A) (vars : Vars) (body : A -> Vars -> monadS RV Vars E) : monadS RV Vars E :=
+ match xs with
+  | [] => returnS vars
+  | x :: xs =>
+     body x vars >>$= fun vars =>
      foreachS xs vars body
-end
+end.
+
+(*val genlistS : forall 'a 'rv 'e. (nat -> monadS 'rv 'a 'e) -> nat -> monadS 'rv (list 'a) 'e*)
+Definition genlistS {A RV E} (f : nat -> monadS RV A E) n : monadS RV (list A) E :=
+  let indices := genlist (fun n => n) n in
+  foreachS indices [] (fun n xs => (f n >>$= (fun x => returnS (xs ++ [x])))).
+
+(*val and_boolS : forall 'rv 'e. monadS 'rv bool 'e -> monadS 'rv bool 'e -> monadS 'rv bool 'e*)
+Definition and_boolS {RV E} (l r : monadS RV bool E) : monadS RV bool E :=
+ l >>$= (fun l => if l then r else returnS false).
+
+(*val or_boolS : forall 'rv 'e. monadS 'rv bool 'e -> monadS 'rv bool 'e -> monadS 'rv bool 'e*)
+Definition or_boolS {RV E} (l r : monadS RV bool E) : monadS RV bool E :=
+ l >>$= (fun l => if l then returnS true else r).
+
+(*val bool_of_bitU_fail : forall 'rv 'e. bitU -> monadS 'rv bool 'e*)
+Definition bool_of_bitU_fail {RV E} (b : bitU) : monadS RV bool E :=
+match b with
+  | B0 => returnS false
+  | B1 => returnS true
+  | BU => failS "bool_of_bitU"
+end.
+
+(*val bool_of_bitU_nondetS : forall 'rv 'e. bitU -> monadS 'rv bool 'e*)
+Definition bool_of_bitU_nondetS {RV E} (b : bitU) : monadS RV bool E :=
+match b with
+  | B0 => returnS false
+  | B1 => returnS true
+  | BU => undefined_boolS tt
+end.
+
+(*val bools_of_bits_nondetS : forall 'rv 'e. list bitU -> monadS 'rv (list bool) 'e*)
+Definition bools_of_bits_nondetS {RV E} bits : monadS RV (list bool) E :=
+  foreachS bits []
+    (fun b bools =>
+      bool_of_bitU_nondetS b >>$= (fun b =>
+      returnS (bools ++ [b]))).
 
-declare {isabelle} termination_argument foreachS = automatic
+(*val of_bits_nondetS : forall 'rv 'a 'e. Bitvector 'a => list bitU -> monadS 'rv 'a 'e*)
+Definition of_bits_nondetS {RV A E} bits `{ArithFact (A >= 0)} : monadS RV (mword A) E :=
+  bools_of_bits_nondetS bits >>$= (fun bs =>
+  returnS (of_bools bs)).
+
+(*val of_bits_failS : forall 'rv 'a 'e. Bitvector 'a => list bitU -> monadS 'rv 'a 'e*)
+Definition of_bits_failS {RV A E} bits `{ArithFact (A >= 0)} : monadS RV (mword A) E :=
+ maybe_failS "of_bits" (of_bits bits).
+
+(*val mword_nondetS : forall 'rv 'a 'e. Size 'a => unit -> monadS 'rv (mword 'a) 'e
+let mword_nondetS () =
+  bools_of_bits_nondetS (repeat [BU] (integerFromNat size)) >>$= (fun bs ->
+  returnS (wordFromBitlist bs))
 
 
 val whileS : forall 'rv 'vars 'e. 'vars -> ('vars -> monadS 'rv bool 'e) ->
@@ -67,3 +96,21 @@ let rec untilS vars cond body s =
   (cond vars >>$= (fun cond_val s'' ->
   if cond_val then returnS vars s'' else untilS vars cond body s'')) s')) s
 *)
+(*val choose_boolsS : forall 'rv 'e. nat -> monadS 'rv (list bool) 'e*)
+Definition choose_boolsS {RV E} n : monadS RV (list bool) E :=
+ genlistS (fun _ => choose_boolS tt) n.
+
+(* TODO: Replace by chooseS and prove equivalence to prompt monad version *)
+(*val internal_pickS : forall 'rv 'a 'e. list 'a -> monadS 'rv 'a 'e
+let internal_pickS xs =
+  (* Use sufficiently many nondeterministically chosen bits and convert into an
+     index into the list *)
+  choose_boolsS (List.length xs) >>$= fun bs ->
+  let idx = (natFromNatural (nat_of_bools bs)) mod List.length xs in
+  match index xs idx with
+    | Just x -> returnS x
+    | Nothing -> failS "choose internal_pick"
+  end
+
+
+*)
diff --git a/lib/coq/Sail2_state_lifting.v b/lib/coq/Sail2_state_lifting.v
new file mode 100644
index 00000000..633c0ef7
--- /dev/null
+++ b/lib/coq/Sail2_state_lifting.v
@@ -0,0 +1,61 @@
+Require Import Sail2_values.
+Require Import Sail2_prompt_monad.
+Require Import Sail2_prompt.
+Require Import Sail2_state_monad.
+Import ListNotations.
+
+(* Lifting from prompt monad to state monad *)
+(*val liftState : forall 'regval 'regs 'a 'e. register_accessors 'regs 'regval -> monad 'regval 'a 'e -> monadS 'regs 'a 'e*)
+Fixpoint liftState {Regval Regs A E} (ra : register_accessors Regs Regval) (m : monad Regval A E) : monadS Regs A E :=
+ match m with
+  | (Done a)                   => returnS a
+  | (Read_mem rk a sz k)       => bindS (read_mem_bytesS rk a sz)       (fun v => liftState ra (k v))
+  | (Read_memt rk a sz k)      => bindS (read_memt_bytesS rk a sz)      (fun v => liftState ra (k v))
+  | (Write_mem wk a sz v k)    => bindS (write_mem_bytesS wk a sz v)    (fun v => liftState ra (k v))
+  | (Write_memt wk a sz v t k) => bindS (write_memt_bytesS wk a sz v t) (fun v => liftState ra (k v))
+  | (Read_reg r k)             => bindS (read_regvalS ra r)             (fun v => liftState ra (k v))
+  | (Excl_res k)               => bindS (excl_resultS tt)               (fun v => liftState ra (k v))
+  | (Choose _ k)               => bindS (choose_boolS tt)               (fun v => liftState ra (k v))
+  | (Write_reg r v k)          => seqS (write_regvalS ra r v)           (liftState ra k)
+  | (Write_ea _ _ _ k)         => liftState ra k
+  | (Footprint k)              => liftState ra k
+  | (Barrier _ k)              => liftState ra k
+  | (Print _ k)                => liftState ra k (* TODO *)
+  | (Fail descr)               => failS descr
+  | (Exception e)              => throwS e
+end.
+
+Local Open Scope bool_scope.
+
+(*val emitEventS : forall 'regval 'regs 'a 'e. Eq 'regval => register_accessors 'regs 'regval -> event 'regval -> sequential_state 'regs -> maybe (sequential_state 'regs)*)
+Definition emitEventS {Regval Regs} `{forall (x y : Regval), Decidable (x = y)} (ra : register_accessors Regs Regval) (e : event Regval) (s : sequential_state Regs) : option (sequential_state Regs) :=
+match e with
+  | E_read_mem _ addr sz v =>
+     option_bind (get_mem_bytes addr sz s) (fun '(v', _) =>
+     if generic_eq v' v then Some s else None)
+  | E_read_memt _ addr sz (v, tag) =>
+     option_bind (get_mem_bytes addr sz s) (fun '(v', tag') =>
+     if generic_eq v' v && generic_eq tag' tag then Some s else None)
+  | E_write_mem _ addr sz v success =>
+     if success then Some (put_mem_bytes addr sz v B0 s) else None
+  | E_write_memt _ addr sz v tag success =>
+     if success then Some (put_mem_bytes addr sz v tag s) else None
+  | E_read_reg r v =>
+     let (read_reg, _) := ra in
+     option_bind (read_reg r s.(regstate)) (fun v' =>
+     if generic_eq v' v then Some s else None)
+  | E_write_reg r v =>
+     let (_, write_reg) := ra in
+     option_bind (write_reg r v s.(regstate)) (fun rs' =>
+     Some {| regstate := rs'; memstate := s.(memstate); tagstate := s.(tagstate) |})
+  | _ => Some s
+end.
+
+Local Close Scope bool_scope.
+
+(*val runTraceS : forall 'regval 'regs 'a 'e. Eq 'regval => register_accessors 'regs 'regval -> trace 'regval -> sequential_state 'regs -> maybe (sequential_state 'regs)*)
+Fixpoint runTraceS {Regval Regs} `{forall (x y : Regval), Decidable (x = y)} (ra : register_accessors Regs Regval) (t : trace Regval) (s : sequential_state Regs) : option (sequential_state Regs) :=
+match t with
+  | [] => Some s
+  | e :: t' => option_bind (emitEventS ra e s) (runTraceS ra t')
+end.
diff --git a/lib/coq/Sail2_state_monad.v b/lib/coq/Sail2_state_monad.v
index c48db31b..235e4b9e 100644
--- a/lib/coq/Sail2_state_monad.v
+++ b/lib/coq/Sail2_state_monad.v
@@ -1,184 +1,237 @@
 Require Import Sail2_instr_kinds.
 Require Import Sail2_values.
-(*
-(* 'a is result type *)
-
-type memstate = map integer memory_byte
-type tagstate = map integer bitU
+Require FMapList.
+Require Import OrderedType.
+Require OrderedTypeEx.
+Require Import List.
+Require bbv.Word.
+Import ListNotations.
+
+(* TODO: revisit choice of FMapList *)
+Module NatMap := FMapList.Make(OrderedTypeEx.Nat_as_OT).
+
+Definition Memstate : Type := NatMap.t memory_byte.
+Definition Tagstate : Type := NatMap.t bitU.
 (* type regstate = map string (vector bitU) *)
 
-type sequential_state 'regs =
-  <| regstate : 'regs;
-     memstate : memstate;
-     tagstate : tagstate;
-     write_ea : maybe (write_kind * integer * integer);
-     last_exclusive_operation_was_load : bool|>
-
-val init_state : forall 'regs. 'regs -> sequential_state 'regs
-let init_state regs =
-  <| regstate = regs;
-     memstate = Map.empty;
-     tagstate = Map.empty;
-     write_ea = Nothing;
-     last_exclusive_operation_was_load = false |>
-
-type ex 'e =
-  | Failure of string
-  | Throw of 'e
-
-type result 'a 'e =
-  | Value of 'a
-  | Ex of (ex 'e)
+Record sequential_state {Regs} :=
+  { regstate : Regs;
+    memstate : Memstate;
+    tagstate : Tagstate }.
+Arguments sequential_state : clear implicits.
+
+(*val init_state : forall 'regs. 'regs -> sequential_state 'regs*)
+Definition init_state {Regs} regs : sequential_state Regs :=
+  {| regstate := regs;
+     memstate := NatMap.empty _;
+     tagstate := NatMap.empty _ |}.
+
+Inductive ex E :=
+  | Failure : string -> ex E
+  | Throw : E -> ex E.
+Arguments Failure {E} _.
+Arguments Throw {E} _.
+
+Inductive result A E :=
+  | Value : A -> result A E
+  | Ex : ex E -> result A E.
+Arguments Value {A} {E} _.
+Arguments Ex {A} {E} _.
 
 (* State, nondeterminism and exception monad with result value type 'a
    and exception type 'e. *)
-type monadS 'regs 'a 'e = sequential_state 'regs -> list (result 'a 'e * sequential_state 'regs)
-
-val returnS : forall 'regs 'a 'e. 'a -> monadS 'regs 'a 'e
-let returnS a s = [(Value a,s)]
-
-val bindS : forall 'regs 'a 'b 'e. monadS 'regs 'a 'e -> ('a -> monadS 'regs 'b 'e) -> monadS 'regs 'b 'e
-let bindS m f (s : sequential_state 'regs) =
-  List.concatMap (function
-                  | (Value a, s') -> f a s'
-                  | (Ex e, s') -> [(Ex e, s')]
-                  end) (m s)
-
-val seqS: forall 'regs 'b 'e. monadS 'regs unit 'e -> monadS 'regs 'b 'e -> monadS 'regs 'b 'e
-let seqS m n = bindS m (fun (_ : unit) -> n)
-
+(* TODO: the list was originally a set, can we reasonably go back to a set? *)
+Definition monadS Regs a e : Type :=
+ sequential_state Regs -> list (result a e * sequential_state Regs).
+
+(*val returnS : forall 'regs 'a 'e. 'a -> monadS 'regs 'a 'e*)
+Definition returnS {Regs A E} (a:A) : monadS Regs A E := fun s => [(Value a,s)].
+
+(*val bindS : forall 'regs 'a 'b 'e. monadS 'regs 'a 'e -> ('a -> monadS 'regs 'b 'e) -> monadS 'regs 'b 'e*)
+Definition bindS {Regs A B E} (m : monadS Regs A E) (f : A -> monadS Regs B E) : monadS Regs B E :=
+ fun (s : sequential_state Regs) =>
+  List.concat (List.map (fun v => match v with
+                | (Value a, s') => f a s'
+                | (Ex e, s') => [(Ex e, s')]
+                end) (m s)).
+
+(*val seqS: forall 'regs 'b 'e. monadS 'regs unit 'e -> monadS 'regs 'b 'e -> monadS 'regs 'b 'e*)
+Definition seqS {Regs B E} (m : monadS Regs unit E) (n : monadS Regs B E) : monadS Regs B E :=
+ bindS m (fun (_ : unit) => n).
+(*
 let inline (>>$=) = bindS
 let inline (>>$) = seqS
-
-val chooseS : forall 'regs 'a 'e. list 'a -> monadS 'regs 'a 'e
-let chooseS xs s = List.map (fun x -> (Value x, s)) xs
-
-val readS : forall 'regs 'a 'e. (sequential_state 'regs -> 'a) -> monadS 'regs 'a 'e
-let readS f = (fun s -> returnS (f s) s)
-
-val updateS : forall 'regs 'e. (sequential_state 'regs -> sequential_state 'regs) -> monadS 'regs unit 'e
-let updateS f = (fun s -> returnS () (f s))
-
-val failS : forall 'regs 'a 'e. string -> monadS 'regs 'a 'e
-let failS msg s = [(Ex (Failure msg), s)]
-
-val exitS : forall 'regs 'e 'a. unit -> monadS 'regs 'a 'e
-let exitS () = failS "exit"
-
-val throwS : forall 'regs 'a 'e. 'e -> monadS 'regs 'a 'e
-let throwS e s = [(Ex (Throw e), s)]
-
-val try_catchS : forall 'regs 'a 'e1 'e2. monadS 'regs 'a 'e1 -> ('e1 -> monadS 'regs 'a 'e2) ->  monadS 'regs 'a 'e2
-let try_catchS m h s =
-  List.concatMap (function
-                  | (Value a, s') -> returnS a s'
-                  | (Ex (Throw e), s') -> h e s'
-                  | (Ex (Failure msg), s') -> [(Ex (Failure msg), s')]
-                  end) (m s)
-
-val assert_expS : forall 'regs 'e. bool -> string -> monadS 'regs unit 'e
-let assert_expS exp msg = if exp then returnS () else failS msg
+*)
+Notation "m >>$= f" := (bindS m f) (at level 50, left associativity).
+Notation "m >>$ n" := (seqS m n) (at level 50, left associativity).
+
+(*val chooseS : forall 'regs 'a 'e. SetType 'a => list 'a -> monadS 'regs 'a 'e*)
+Definition chooseS {Regs A E} (xs : list A) : monadS Regs A E :=
+ fun s => (List.map (fun x => (Value x, s)) xs).
+
+(*val readS : forall 'regs 'a 'e. (sequential_state 'regs -> 'a) -> monadS 'regs 'a 'e*)
+Definition readS {Regs A E} (f : sequential_state Regs -> A) : monadS Regs A E :=
+ (fun s => returnS (f s) s).
+
+(*val updateS : forall 'regs 'e. (sequential_state 'regs -> sequential_state 'regs) -> monadS 'regs unit 'e*)
+Definition updateS {Regs E} (f : sequential_state Regs -> sequential_state Regs) : monadS Regs unit E :=
+ (fun s => returnS tt (f s)).
+
+(*val failS : forall 'regs 'a 'e. string -> monadS 'regs 'a 'e*)
+Definition failS {Regs A E} msg : monadS Regs A E :=
+ fun s => [(Ex (Failure msg), s)].
+
+(*val choose_boolS : forall 'regval 'regs 'a 'e. unit -> monadS 'regs bool 'e*)
+Definition choose_boolS {Regs E} (_:unit) : monadS Regs bool E :=
+ chooseS [false; true].
+Definition undefined_boolS {Regs E} := @choose_boolS Regs E.
+
+(*val exitS : forall 'regs 'e 'a. unit -> monadS 'regs 'a 'e*)
+Definition exitS {Regs A E} (_:unit) : monadS Regs A E := failS "exit".
+
+(*val throwS : forall 'regs 'a 'e. 'e -> monadS 'regs 'a 'e*)
+Definition throwS {Regs A E} (e : E) :monadS Regs A E :=
+ fun s => [(Ex (Throw e), s)].
+
+(*val try_catchS : forall 'regs 'a 'e1 'e2. monadS 'regs 'a 'e1 -> ('e1 -> monadS 'regs 'a 'e2) ->  monadS 'regs 'a 'e2*)
+Definition try_catchS {Regs A E1 E2} (m : monadS Regs A E1) (h : E1 -> monadS Regs A E2) : monadS Regs A E2 :=
+fun s =>
+  List.concat (List.map (fun v => match v with
+                | (Value a, s') => returnS a s'
+                | (Ex (Throw e), s') => h e s'
+                | (Ex (Failure msg), s') => [(Ex (Failure msg), s')]
+                end) (m s)).
+
+(*val assert_expS : forall 'regs 'e. bool -> string -> monadS 'regs unit 'e*)
+Definition assert_expS {Regs E} (exp : bool) (msg : string) : monadS Regs unit E :=
+ if exp then returnS tt else failS msg.
 
 (* For early return, we abuse exceptions by throwing and catching
    the return value. The exception type is "either 'r 'e", where "Right e"
    represents a proper exception and "Left r" an early return of value "r". *)
-type monadSR 'regs 'a 'r 'e = monadS 'regs 'a (either 'r 'e)
+Definition monadRS Regs A R E := monadS Regs A (sum R E).
 
-val early_returnS : forall 'regs 'a 'r 'e. 'r -> monadSR 'regs 'a 'r 'e
-let early_returnS r = throwS (Left r)
+(*val early_returnS : forall 'regs 'a 'r 'e. 'r -> monadRS 'regs 'a 'r 'e*)
+Definition early_returnS {Regs A R E} (r : R) : monadRS Regs A R E := throwS (inl r).
 
-val catch_early_returnS : forall 'regs 'a 'e. monadSR 'regs 'a 'a 'e -> monadS 'regs 'a 'e
-let catch_early_returnS m =
+(*val catch_early_returnS : forall 'regs 'a 'e. monadRS 'regs 'a 'a 'e -> monadS 'regs 'a 'e*)
+Definition catch_early_returnS {Regs A E} (m : monadRS Regs A A E) : monadS Regs A E :=
   try_catchS m
-    (function
-      | Left a -> returnS a
-      | Right e -> throwS e
-     end)
+    (fun v => match v with
+      | inl a => returnS a
+      | inr e => throwS e
+     end).
 
 (* Lift to monad with early return by wrapping exceptions *)
-val liftSR : forall 'a 'r 'regs 'e. monadS 'regs 'a 'e -> monadSR 'regs 'a 'r 'e
-let liftSR m = try_catchS m (fun e -> throwS (Right e))
+(*val liftRS : forall 'a 'r 'regs 'e. monadS 'regs 'a 'e -> monadRS 'regs 'a 'r 'e*)
+Definition liftRS {A R Regs E} (m : monadS Regs A E) : monadRS Regs A R E :=
+ try_catchS m (fun e => throwS (inr e)).
 
 (* Catch exceptions in the presence of early returns *)
-val try_catchSR : forall 'regs 'a 'r 'e1 'e2. monadSR 'regs 'a 'r 'e1 -> ('e1 -> monadSR 'regs 'a 'r 'e2) ->  monadSR 'regs 'a 'r 'e2
-let try_catchSR m h =
+(*val try_catchRS : forall 'regs 'a 'r 'e1 'e2. monadRS 'regs 'a 'r 'e1 -> ('e1 -> monadRS 'regs 'a 'r 'e2) ->  monadRS 'regs 'a 'r 'e2*)
+Definition try_catchRS {Regs A R E1 E2} (m : monadRS Regs A R E1) (h : E1 -> monadRS Regs A R E2) : monadRS Regs A R E2 :=
   try_catchS m
-    (function
-      | Left r -> throwS (Left r)
-      | Right e -> h e
-     end)
+    (fun v => match v with
+      | inl r => throwS (inl r)
+      | inr e => h e
+     end).
+
+(*val maybe_failS : forall 'regs 'a 'e. string -> maybe 'a -> monadS 'regs 'a 'e*)
+Definition maybe_failS {Regs A E} msg (v : option A) : monadS Regs A E :=
+match v with
+  | Some a  => returnS a
+  | None => failS msg
+end.
+
+(*val read_tagS : forall 'regs 'a 'e. Bitvector 'a => 'a -> monadS 'regs bitU 'e*)
+Definition read_tagS {Regs A E} (addr : mword A) : monadS Regs bitU E :=
+  let addr := Word.wordToNat (get_word addr) in
+  readS (fun s => opt_def B0 (NatMap.find addr s.(tagstate))).
+
+Fixpoint genlist_acc {A:Type} (f : nat -> A) n acc : list A :=
+  match n with
+    | O => acc
+    | S n' => genlist_acc f n' (f n' :: acc)
+  end.
+Definition genlist {A} f n := @genlist_acc A f n [].
 
-val read_tagS : forall 'regs 'a 'e. Bitvector 'a => 'a -> monadS 'regs bitU 'e
-let read_tagS addr =
-  readS (fun s -> fromMaybe B0 (Map.lookup (unsigned addr) s.tagstate))
 
 (* Read bytes from memory and return in little endian order *)
-val read_mem_bytesS : forall 'regs 'e 'a. Bitvector 'a => read_kind -> 'a -> nat -> monadS 'regs (list memory_byte) 'e
-let read_mem_bytesS read_kind addr sz =
-  let addr = unsigned addr in
-  let sz = integerFromNat sz in
-  let addrs = index_list addr (addr+sz-1) 1 in
-  let read_byte s addr = Map.lookup addr s.memstate in
-  readS (fun s -> just_list (List.map (read_byte s) addrs)) >>$= (function
-    | Just mem_val ->
-       updateS (fun s ->
-         if read_is_exclusive read_kind
-         then <| s with last_exclusive_operation_was_load = true |>
-         else s) >>$
-       returnS mem_val
-    | Nothing -> failS "read_memS"
-  end)
-
-val read_memS : forall 'regs 'e 'a 'b. Bitvector 'a, Bitvector 'b => read_kind -> 'a -> integer -> monadS 'regs 'b 'e
-let read_memS rk a sz =
-  read_mem_bytesS rk a (natFromInteger sz) >>$= (fun bytes ->
-  returnS (bits_of_mem_bytes bytes))
-
-val excl_resultS : forall 'regs 'e. unit -> monadS 'regs bool 'e
-let excl_resultS () =
-  readS (fun s -> s.last_exclusive_operation_was_load) >>$= (fun excl_load ->
-  updateS (fun s -> <| s with last_exclusive_operation_was_load = false |>) >>$
-  chooseS (if excl_load then [false; true] else [false]))
-
-val write_mem_eaS : forall 'regs 'e 'a. Bitvector 'a => write_kind -> 'a -> nat -> monadS 'regs unit 'e
-let write_mem_eaS write_kind addr sz =
-  let addr = unsigned addr in
-  let sz = integerFromNat sz in
-  updateS (fun s -> <| s with write_ea = Just (write_kind, addr, sz) |>)
-
-(* Write little-endian list of bytes to previously announced address *)
-val write_mem_bytesS : forall 'regs 'e. list memory_byte -> monadS 'regs bool 'e
-let write_mem_bytesS v =
-  readS (fun s -> s.write_ea) >>$= (function
-      | Nothing -> failS "write ea has not been announced yet"
-      | Just (_, addr, sz) ->
-         let addrs = index_list addr (addr+sz-1) 1 in
-         (*let v = external_mem_value (bits_of v) in*)
-         let a_v = List.zip addrs v in
-         let write_byte mem (addr, v) = Map.insert addr v mem in
-         updateS (fun s ->
-           <| s with memstate = List.foldl write_byte s.memstate a_v |>) >>$
-         returnS true
-    end)
-
-val write_mem_valS : forall 'regs 'e 'a. Bitvector 'a => 'a -> monadS 'regs bool 'e
-let write_mem_valS v = match mem_bytes_of_bits v with
-  | Just v -> write_mem_bytesS v
-  | Nothing -> failS "write_mem_val"
-end
-
-val write_tagS : forall 'regs 'e. bitU -> monadS 'regs bool 'e
-let write_tagS t =
-  readS (fun s -> s.write_ea) >>$= (function
-      | Nothing -> failS "write ea has not been announced yet"
-      | Just (_, addr, _) ->
-         (*let taddr = addr / cap_alignment in*)
-         updateS (fun s -> <| s with tagstate = Map.insert addr t s.tagstate |>) >>$
-         returnS true
-    end)
-
-val read_regS : forall 'regs 'rv 'a 'e. register_ref 'regs 'rv 'a -> monadS 'regs 'a 'e
-let read_regS reg = readS (fun s -> reg.read_from s.regstate)
+(*val get_mem_bytes : forall 'regs. nat -> nat -> sequential_state 'regs -> maybe (list memory_byte * bitU)*)
+Definition get_mem_bytes {Regs} addr sz (s : sequential_state Regs) : option (list memory_byte * bitU) :=
+  let addrs := genlist (fun n => addr + n)%nat sz in
+  let read_byte s addr := NatMap.find addr s.(memstate) in
+  let read_tag s addr := opt_def B0 (NatMap.find addr s.(tagstate)) in
+  option_map
+    (fun mem_val => (mem_val, List.fold_left and_bit (List.map (read_tag s) addrs) B1))
+    (just_list (List.map (read_byte s) addrs)).
+
+(*val read_memt_bytesS : forall 'regs 'e. read_kind -> nat -> nat -> monadS 'regs (list memory_byte * bitU) 'e*)
+Definition read_memt_bytesS {Regs E} (_ : read_kind) addr sz : monadS Regs (list memory_byte * bitU) E :=
+  readS (get_mem_bytes addr sz) >>$=
+  maybe_failS "read_memS".
+
+(*val read_mem_bytesS : forall 'regs 'e. read_kind -> nat -> nat -> monadS 'regs (list memory_byte) 'e*)
+Definition read_mem_bytesS {Regs E} (rk : read_kind) addr sz : monadS Regs (list memory_byte) E :=
+  read_memt_bytesS rk addr sz >>$= (fun '(bytes, _) =>
+  returnS bytes).
+
+(*val read_memtS : forall 'regs 'e 'a 'b. Bitvector 'a, Bitvector 'b => read_kind -> 'a -> integer -> monadS 'regs ('b * bitU) 'e*)
+Definition read_memtS {Regs E A B} (rk : read_kind) (a : mword A) sz `{ArithFact (B >= 0)} : monadS Regs (mword B * bitU) E :=
+  let a := Word.wordToNat (get_word a) in
+  read_memt_bytesS rk a (Z.to_nat sz) >>$= (fun '(bytes, tag) =>
+  maybe_failS "bits_of_mem_bytes" (of_bits (bits_of_mem_bytes bytes)) >>$= (fun mem_val =>
+  returnS (mem_val, tag))).
+
+(*val read_memS : forall 'regs 'e 'a 'b. Bitvector 'a, Bitvector 'b => read_kind -> 'a -> integer -> monadS 'regs 'b 'e*)
+Definition read_memS {Regs E A B} rk (a : mword A) sz `{ArithFact (B >= 0)} : monadS Regs (mword B) E :=
+  read_memtS rk a sz >>$= (fun '(bytes, _) =>
+  returnS bytes).
+
+(*val excl_resultS : forall 'regs 'e. unit -> monadS 'regs bool 'e*)
+Definition excl_resultS {Regs E} : unit -> monadS Regs bool E :=
+  (* TODO: This used to be more deterministic, checking a flag in the state
+     whether an exclusive load has occurred before.  However, this does not
+     seem very precise; it might be safer to overapproximate the possible
+     behaviours by always making a nondeterministic choice. *)
+  @undefined_boolS Regs E.
+
+(* Write little-endian list of bytes to given address *)
+(*val put_mem_bytes : forall 'regs. nat -> nat -> list memory_byte -> bitU -> sequential_state 'regs -> sequential_state 'regs*)
+Definition put_mem_bytes {Regs} addr sz (v : list memory_byte) (tag : bitU) (s : sequential_state Regs) : sequential_state Regs :=
+  let addrs := genlist (fun n => addr + n)%nat sz in
+  let a_v := List.combine addrs v in
+  let write_byte mem '(addr, v) := NatMap.add addr v mem in
+  let write_tag mem addr := NatMap.add addr tag mem in
+  {| regstate := s.(regstate);
+     memstate := List.fold_left write_byte a_v s.(memstate);
+     tagstate := List.fold_left write_tag addrs s.(tagstate) |}.
+
+(*val write_memt_bytesS : forall 'regs 'e. write_kind -> nat -> nat -> list memory_byte -> bitU -> monadS 'regs bool 'e*)
+Definition write_memt_bytesS {Regs E} (_ : write_kind) addr sz (v : list memory_byte) (t : bitU) : monadS Regs bool E :=
+  updateS (put_mem_bytes addr sz v t) >>$
+  returnS true.
+
+(*val write_mem_bytesS : forall 'regs 'e. write_kind -> nat -> nat -> list memory_byte -> monadS 'regs bool 'e*)
+Definition write_mem_bytesS {Regs E} wk addr sz (v : list memory_byte) : monadS Regs bool E :=
+ write_memt_bytesS wk addr sz v B0.
+
+(*val write_memtS : forall 'regs 'e 'a 'b. Bitvector 'a, Bitvector 'b =>
+  write_kind -> 'a -> integer -> 'b -> bitU -> monadS 'regs bool 'e*)
+Definition write_memtS {Regs E A B} wk (addr : mword A) sz (v : mword B) (t : bitU) : monadS Regs bool E :=
+  match (Word.wordToNat (get_word addr), mem_bytes_of_bits v) with
+    | (addr, Some v) => write_memt_bytesS wk addr (Z.to_nat sz) v t
+    | _ => failS "write_mem"
+  end.
+
+(*val write_memS : forall 'regs 'e 'a 'b. Bitvector 'a, Bitvector 'b =>
+  write_kind -> 'a -> integer -> 'b -> monadS 'regs bool 'e*)
+Definition write_memS {Regs E A B} wk (addr : mword A) sz (v : mword B) : monadS Regs bool E :=
+ write_memtS wk addr sz v B0.
+
+(*val read_regS : forall 'regs 'rv 'a 'e. register_ref 'regs 'rv 'a -> monadS 'regs 'a 'e*)
+Definition read_regS {Regs RV A E} (reg : register_ref Regs RV A) : monadS Regs A E :=
+ readS (fun s => reg.(read_from) s.(regstate)).
 
 (* TODO
 let read_reg_range reg i j state =
@@ -194,25 +247,27 @@ let read_reg_bitfield reg regfield =
   let (i,_) = register_field_indices reg regfield in
   read_reg_bit reg i *)
 
-val read_regvalS : forall 'regs 'rv 'e.
-  register_accessors 'regs 'rv -> string -> monadS 'regs 'rv 'e
-let read_regvalS (read, _) reg =
-  readS (fun s -> read reg s.regstate) >>$= (function
-      | Just v ->  returnS v
-      | Nothing -> failS ("read_regvalS " ^ reg)
-    end)
-
-val write_regvalS : forall 'regs 'rv 'e.
-  register_accessors 'regs 'rv -> string -> 'rv -> monadS 'regs unit 'e
-let write_regvalS (_, write) reg v =
-  readS (fun s -> write reg v s.regstate) >>$= (function
-      | Just rs' -> updateS (fun s -> <| s with regstate = rs' |>)
-      | Nothing ->  failS ("write_regvalS " ^ reg)
-    end)
-
-val write_regS : forall 'regs 'rv 'a 'e. register_ref 'regs 'rv 'a -> 'a -> monadS 'regs unit 'e
-let write_regS reg v =
-  updateS (fun s -> <| s with regstate = reg.write_to v s.regstate |>)
+(*val read_regvalS : forall 'regs 'rv 'e.
+  register_accessors 'regs 'rv -> string -> monadS 'regs 'rv 'e*)
+Definition read_regvalS {Regs RV E} (acc : register_accessors Regs RV) reg : monadS Regs RV E :=
+  let '(read, _) := acc in
+  readS (fun s => read reg s.(regstate)) >>$= (fun v => match v with
+      | Some v =>  returnS v
+      | None => failS ("read_regvalS " ++ reg)
+    end).
+
+(*val write_regvalS : forall 'regs 'rv 'e.
+  register_accessors 'regs 'rv -> string -> 'rv -> monadS 'regs unit 'e*)
+Definition write_regvalS {Regs RV E} (acc : register_accessors Regs RV) reg (v : RV) : monadS Regs unit E :=
+  let '(_, write) := acc in
+  readS (fun s => write reg v s.(regstate)) >>$= (fun x => match x with
+      | Some rs' => updateS (fun s => {| regstate := rs'; memstate := s.(memstate); tagstate := s.(tagstate) |})
+      | None =>  failS ("write_regvalS " ++ reg)
+    end).
+
+(*val write_regS : forall 'regs 'rv 'a 'e. register_ref 'regs 'rv 'a -> 'a -> monadS 'regs unit 'e*)
+Definition write_regS {Regs RV A E} (reg : register_ref Regs RV A) (v:A) : monadS Regs unit E :=
+  updateS (fun s => {| regstate := reg.(write_to) v s.(regstate); memstate := s.(memstate); tagstate := s.(tagstate) |}).
 
 (* TODO
 val update_reg : forall 'regs 'rv 'a 'b 'e. register_ref 'regs 'rv 'a -> ('a -> 'b -> 'a) -> 'b -> monadS 'regs unit 'e
@@ -250,4 +305,17 @@ let update_reg_field_bit regfield i reg_val bit =
   let new_field_value = set_bit (regfield.field_is_inc) current_field_value i (to_bitU bit) in
   regfield.set_field reg_val new_field_value
 let write_reg_field_bit reg regfield i = update_reg reg (update_reg_field_bit regfield i)*)
-*)
+
+(* TODO Add Show typeclass for value and exception type *)
+(*val show_result : forall 'a 'e. result 'a 'e -> string*)
+Definition show_result {A E} (x : result A E) : string := match x with
+  | Value _ => "Value ()"
+  | Ex (Failure msg) => "Failure " ++ msg
+  | Ex (Throw _) => "Throw"
+end.
+
+(*val prerr_results : forall 'a 'e 's. SetType 's => set (result 'a 'e * 's) -> unit*)
+Definition prerr_results {A E S} (rs : list (result A E * S)) : unit := tt.
+(*  let _ = Set.map (fun (r, _) -> let _ = prerr_endline (show_result r) in ()) rs in
+  ()*)
+
diff --git a/lib/coq/Sail2_values.v b/lib/coq/Sail2_values.v
index 7edc8843..8c9c40a3 100644
--- a/lib/coq/Sail2_values.v
+++ b/lib/coq/Sail2_values.v
@@ -110,6 +110,9 @@ refine ((if Decidable_witness as b return (b = true <-> x = y -> _) then fun H'
 * right. intuition.
 Defined.
 
+Instance Decidable_eq_list {A : Type} `(D : forall x y : A, Decidable (x = y)) : forall (x y : list A), Decidable (x = y) :=
+  Decidable_eq_from_dec (list_eq_dec (fun x y => generic_dec x y)).
+
 (* Used by generated code that builds Decidable equality instances for records. *)
 Ltac cmp_record_field x y :=
   let H := fresh "H" in
@@ -457,19 +460,23 @@ Definition binop_bit op x y :=
   match (x, y) with
   | (BU,_) => BU (*Do we want to do this or to respect | of I and & of B0 rules?*)
   | (_,BU) => BU (*Do we want to do this or to respect | of I and & of B0 rules?*)
-  | (x,y) => bitU_of_bool (op (bool_of_bitU x) (bool_of_bitU y))
+(*  | (x,y) => bitU_of_bool (op (bool_of_bitU x) (bool_of_bitU y))*)
+  | (B0,B0) => bitU_of_bool (op false false)
+  | (B0,B1) => bitU_of_bool (op false  true)
+  | (B1,B0) => bitU_of_bool (op  true false)
+  | (B1,B1) => bitU_of_bool (op  true  true)
   end.
 
-(*val and_bit : bitU -> bitU -> bitU
-Definition and_bit := binop_bit (&&)
+(*val and_bit : bitU -> bitU -> bitU*)
+Definition and_bit := binop_bit andb.
 
-val or_bit : bitU -> bitU -> bitU
-Definition or_bit := binop_bit (||)
+(*val or_bit : bitU -> bitU -> bitU*)
+Definition or_bit := binop_bit orb.
 
-val xor_bit : bitU -> bitU -> bitU
-Definition xor_bit := binop_bit xor
+(*val xor_bit : bitU -> bitU -> bitU*)
+Definition xor_bit := binop_bit xorb.
 
-val (&.) : bitU -> bitU -> bitU
+(*val (&.) : bitU -> bitU -> bitU
 Definition inline (&.) x y := and_bit x y
 
 val (|.) : bitU -> bitU -> bitU
@@ -546,15 +553,23 @@ end.
 Definition add_one_bool_ignore_overflow bits :=
   List.rev (add_one_bool_ignore_overflow_aux (List.rev bits)).
 
-(*let bool_list_of_int n =
-  let bs_abs = false :: bools_of_nat (naturalFromInteger (abs n)) in
-  if n >= (0 : integer) then bs_abs
-  else add_one_bool_ignore_overflow (List.map not bs_abs)
-let bools_of_int len n = exts_bools len (bool_list_of_int n)*)
+(* Ported from Lem, bad for large n.
 Definition bools_of_int len n :=
   let bs_abs := bools_of_nat len (Z.abs_nat n) in
   if n >=? 0 then bs_abs
   else add_one_bool_ignore_overflow (List.map negb bs_abs).
+*)
+Fixpoint bitlistFromWord_rev {n} w :=
+match w with
+| WO => []
+| WS b w => b :: bitlistFromWord_rev w
+end.
+Definition bitlistFromWord {n} w :=
+  List.rev (@bitlistFromWord_rev n w).
+
+Definition bools_of_int len n :=
+  let w := Word.ZToWord (Z.to_nat len) n in
+  bitlistFromWord w.
 
 (*** Bit lists ***)
 
@@ -963,14 +978,6 @@ val make_the_value : forall n. Z -> itself n
 Definition inline make_the_value x := the_value
 *)
 
-Fixpoint bitlistFromWord_rev {n} w :=
-match w with
-| WO => []
-| WS b w => b :: bitlistFromWord_rev w
-end.
-Definition bitlistFromWord {n} w :=
-  List.rev (@bitlistFromWord_rev n w).
-
 Fixpoint wordFromBitlist_rev l : word (length l) :=
 match l with
 | [] => WO
@@ -1218,9 +1225,10 @@ Ltac prepare_for_solver :=
  unfold_In; (* after unbool_comparisons to deal with && and || *)
  reduce_list_lengths;
  reduce_pow;
- (* omega doesn't cope well with extra "True"s in the goal *)
- repeat setoid_rewrite True_left;
- repeat setoid_rewrite True_right.
+ (* omega doesn't cope well with extra "True"s in the goal.
+    Check that they actually appear because setoid_rewrite can fill in evars. *)
+ repeat match goal with |- context[True /\ _] => setoid_rewrite True_left end;
+ repeat match goal with |- context[_ /\ True] => setoid_rewrite True_right end.
 
 Lemma trivial_range {x : Z} : ArithFact (x <= x /\ x <= x).
 constructor.
@@ -1285,7 +1293,7 @@ prepare_for_solver;
 constructor;
 repeat match goal with |- and _ _ => split end;
  solve
- [ match goal with |- (?x _) => is_evar x; idtac "Warning: unknown constraint"; exact (I : (fun _ => True) _) end
+ [ match goal with |- (?x ?y) => is_evar x; idtac "Warning: unknown constraint"; exact (I : (fun _ => True) y) end
  | apply ArithFact_mword; assumption
  | omega with Z
    (* Try sail hints before dropping the existential *)
@@ -1941,3 +1949,20 @@ Definition min_nat (x : Z) `{ArithFact (x >= 0)} (y : Z) `{ArithFact (y >= 0)} :
 Definition max_nat (x : Z) `{ArithFact (x >= 0)} (y : Z) `{ArithFact (y >= 0)} :
   {z : Z & ArithFact (z >= 0)} :=
   build_ex (Z.max x y).
+
+Definition shl_int_8 (x y : Z) `{HE:ArithFact (x = 8)} `{HR:ArithFact (0 <= y <= 3)}: {z : Z & ArithFact (In z [8;16;32;64])}.
+refine (existT _ (shl_int x y) _).
+destruct HE as [HE].
+destruct HR as [HR].
+assert (H : y = 0 \/ y = 1 \/ y = 2 \/ y = 3) by omega.
+constructor.
+intuition (subst; compute; auto).
+Defined.
+
+Definition shl_int_32 (x y : Z) `{HE:ArithFact (x = 32)} `{HR:ArithFact (In y [0;1])}: {z : Z & ArithFact (In z [32;64])}.
+refine (existT _ (shl_int x y) _).
+destruct HE as [HE].
+destruct HR as [[HR1 | [HR2 | []]]];
+subst; compute;
+auto using Build_ArithFact.
+Defined.
diff --git a/lib/elf.sail b/lib/elf.sail
index 2d799d4d..6ea5de19 100644
--- a/lib/elf.sail
+++ b/lib/elf.sail
@@ -3,12 +3,14 @@ $define _ELF
 
 val elf_entry = {
   ocaml: "Elf_loader.elf_entry",
+  interpreter: "Elf_loader.elf_entry",
   lem: "elf_entry",
   c: "elf_entry"
 } : unit -> int
 
 val elf_tohost = {
   ocaml: "Elf_loader.elf_tohost",
+  interpreter: "Elf_loader.elf_tohost",
   lem: "elf_tohost",
   c: "elf_tohost"
 } : unit -> int
diff --git a/lib/flow.sail b/lib/flow.sail
index e6fe7fc0..5c69a128 100644
--- a/lib/flow.sail
+++ b/lib/flow.sail
@@ -25,9 +25,9 @@ val and_bool_no_flow = {coq: "andb", _: "and_bool"} : (bool, bool) -> bool
 
 val or_bool = {coq: "orb", _: "or_bool"} : forall ('p : Bool) ('q : Bool). (bool('p), bool('q)) -> bool('p | 'q)
 
-val eq_int = {ocaml: "eq_int", lem: "eq", c: "eq_int", coq: "Z.eqb"} : forall 'n 'm. (int('n), int('m)) -> bool('n == 'm)
+val eq_int = {ocaml: "eq_int", interpreter: "eq_int", lem: "eq", c: "eq_int", coq: "Z.eqb"} : forall 'n 'm. (int('n), int('m)) -> bool('n == 'm)
 
-val eq_bool = {ocaml: "eq_bool", lem: "eq", c: "eq_bool", coq: "Bool.eqb"} : (bool, bool) -> bool
+val eq_bool = {ocaml: "eq_bool", interpreter: "eq_bool", lem: "eq", c: "eq_bool", coq: "Bool.eqb"} : (bool, bool) -> bool
 
 val neq_int = {lem: "neq"} : forall 'n 'm. (int('n), int('m)) -> bool('n != 'm)
 function neq_int (x, y) = not_bool(eq_int(x, y))
diff --git a/lib/hol/sail2_prompt_monad.lem b/lib/hol/sail2_prompt_monad.lem
index ade12347..896c1a9c 100644
--- a/lib/hol/sail2_prompt_monad.lem
+++ b/lib/hol/sail2_prompt_monad.lem
@@ -44,7 +44,7 @@ let inline read_memt = read_memtS
 let inline read_mem = read_memS
 let inline excl_result = excl_resultS
 let inline write_reg = write_regS
-let inline write_mem_ea wk addr sz = return ()
+let inline write_mem_ea wk addrsize addr sz = return ()
 let inline write_memt = write_memtS
 let inline write_mem = write_memS
 let barrier _ = return ()
diff --git a/lib/instr_kinds.sail b/lib/instr_kinds.sail
new file mode 100644
index 00000000..66ef90c6
--- /dev/null
+++ b/lib/instr_kinds.sail
@@ -0,0 +1,28 @@
+union read_kind = {
+  Read_plain : unit,
+  Read_reserve : unit,
+  Read_acquire : unit,
+  Read_exclusive : unit,
+  Read_exclusive_acquire : unit,
+  Read_stream : unit,
+  Read_RISCV_acquire : unit,
+  Read_RISCV_strong_acquire : unit,
+  Read_RISCV_reserved : unit,
+  Read_RISCV_reserved_acquire : unit,
+  Read_RISCV_reserved_strong_acquire : unit,
+  Read_X86_locked : unit
+}
+
+union write_kind = {
+  Write_plain  : unit
+  Write_conditional : unit
+  Write_release : unit
+  Write_exclusive : unit
+  Write_exclusive_release : unit
+  Write_RISCV_release : unit
+  Write_RISCV_strong_release : unit
+  Write_RISCV_conditional : unit
+  Write_RISCV_conditional_release : unit
+  Write_RISCV_conditional_strong_release : unit
+  Write_X86_locked : unit
+}
\ No newline at end of file
diff --git a/lib/isabelle/Sail2_state_lemmas.thy b/lib/isabelle/Sail2_state_lemmas.thy
index 8b189f7a..e8148597 100644
--- a/lib/isabelle/Sail2_state_lemmas.thy
+++ b/lib/isabelle/Sail2_state_lemmas.thy
@@ -91,7 +91,7 @@ lemma liftState_read_memt[liftState_simp]:
            split: option.splits intro: bindS_cong)
 
 lemma liftState_read_mem[liftState_simp]:
-  shows "liftState r (read_mem BCa BCb rk a sz) = read_memS BCa BCb rk a sz"
+  shows "liftState r (read_mem BCa BCb rk asz a sz) = read_memS BCa BCb rk a sz"
   by (auto simp: read_mem_def read_mem_bytes_def read_memS_def read_mem_bytesS_def maybe_failS_def
                  read_memtS_def
                  prod.case_distrib option.case_distrib[where h = "liftState r"]
@@ -100,7 +100,7 @@ lemma liftState_read_mem[liftState_simp]:
 
 lemma liftState_write_mem_ea_BC:
   assumes "unsigned_method BCa a = Some a'"
-  shows "liftState r (write_mem_ea BCa rk a sz) = returnS ()"
+  shows "liftState r (write_mem_ea BCa rk asz a sz) = returnS ()"
   using assms by (auto simp: write_mem_ea_def nat_of_bv_def maybe_fail_def)
 
 (*lemma liftState_write_mem_ea[liftState_simp]:
@@ -118,7 +118,7 @@ lemma liftState_write_memt[liftState_simp]:
   by (auto simp: write_memt_def write_memtS_def liftState_simp split: option.splits)
 
 lemma liftState_write_mem[liftState_simp]:
-  "liftState r (write_mem BCa BCv wk addr sz v) = write_memS BCa BCv wk addr sz v"
+  "liftState r (write_mem BCa BCv wk addrsize addr sz v) = write_memS BCa BCv wk addr sz v"
   by (auto simp: write_mem_def write_memS_def write_memtS_def write_mem_bytesS_def liftState_simp
            split: option.splits)
 
diff --git a/lib/isabelle/output/document/Sail2_operators_bitlists.tex b/lib/isabelle/output/document/Sail2_operators_bitlists.tex
new file mode 100644
index 00000000..a676b7bf
--- /dev/null
+++ b/lib/isabelle/output/document/Sail2_operators_bitlists.tex
@@ -0,0 +1,1810 @@
+%
+\begin{isabellebody}%
+\setisabellecontext{Sail{\isadigit{2}}{\isacharunderscore}operators{\isacharunderscore}bitlists}%
+%
+\isadelimdocument
+%
+\endisadelimdocument
+%
+\isatagdocument
+%
+\isamarkupchapter{Generated by Lem from \isa{{\isachardot}{\isachardot}{\isacharslash}{\isachardot}{\isachardot}{\isacharslash}src{\isacharslash}gen{\isacharunderscore}lib{\isacharslash}sail{\isadigit{2}}{\isacharunderscore}operators{\isacharunderscore}bitlists{\isachardot}lem}.%
+}
+\isamarkuptrue%
+%
+\endisatagdocument
+{\isafolddocument}%
+%
+\isadelimdocument
+%
+\endisadelimdocument
+%
+\isadelimtheory
+%
+\endisadelimtheory
+%
+\isatagtheory
+\isacommand{theory}\isamarkupfalse%
+\ {\isachardoublequoteopen}Sail{\isadigit{2}}{\isacharunderscore}operators{\isacharunderscore}bitlists{\isachardoublequoteclose}\ \isanewline
+\isanewline
+\isakeyword{imports}\isanewline
+\ \ Main\isanewline
+\ \ {\isachardoublequoteopen}LEM{\isachardot}Lem{\isacharunderscore}pervasives{\isacharunderscore}extra{\isachardoublequoteclose}\isanewline
+\ \ {\isachardoublequoteopen}LEM{\isachardot}Lem{\isacharunderscore}machine{\isacharunderscore}word{\isachardoublequoteclose}\isanewline
+\ \ {\isachardoublequoteopen}Sail{\isadigit{2}}{\isacharunderscore}values{\isachardoublequoteclose}\isanewline
+\ \ {\isachardoublequoteopen}Sail{\isadigit{2}}{\isacharunderscore}operators{\isachardoublequoteclose}\isanewline
+\ \ {\isachardoublequoteopen}Sail{\isadigit{2}}{\isacharunderscore}prompt{\isacharunderscore}monad{\isachardoublequoteclose}\isanewline
+\ \ {\isachardoublequoteopen}Sail{\isadigit{2}}{\isacharunderscore}prompt{\isachardoublequoteclose}\isanewline
+\isanewline
+\isakeyword{begin}\ \isanewline
+\isanewline
+%
+\isamarkupcmt{\isa{open\ import\ Pervasives{\isacharunderscore}extra}%
+}\isanewline
+%
+\isamarkupcmt{\isa{open\ import\ Machine{\isacharunderscore}word}%
+}\isanewline
+%
+\isamarkupcmt{\isa{open\ import\ Sail{\isadigit{2}}{\isacharunderscore}values}%
+}\isanewline
+%
+\isamarkupcmt{\isa{open\ import\ Sail{\isadigit{2}}{\isacharunderscore}operators}%
+}\isanewline
+%
+\isamarkupcmt{\isa{open\ import\ Sail{\isadigit{2}}{\isacharunderscore}prompt{\isacharunderscore}monad}%
+}\isanewline
+%
+\isamarkupcmt{\isa{open\ import\ Sail{\isadigit{2}}{\isacharunderscore}prompt}%
+}\isanewline
+\isanewline
+%
+\isamarkupcmt{\isa{Specialisation\ of\ operators\ to\ bit\ lists}%
+}\isanewline
+\isanewline
+%
+\isamarkupcmt{\isa{val\ uint{\isacharunderscore}maybe\ {\isacharcolon}\ list\ bitU\ {\isacharminus}{\isachargreater}\ maybe\ integer}%
+}%
+\endisatagtheory
+{\isafoldtheory}%
+%
+\isadelimtheory
+\isanewline
+%
+\endisadelimtheory
+\isacommand{definition}\isamarkupfalse%
+\ uint{\isacharunderscore}maybe\ \ {\isacharcolon}{\isacharcolon}\ {\isachardoublequoteopen}{\isacharparenleft}bitU{\isacharparenright}list\ {\isasymRightarrow}{\isacharparenleft}int{\isacharparenright}option\ {\isachardoublequoteclose}\ \ \isakeyword{where}\ \isanewline
+\ \ \ \ \ {\isachardoublequoteopen}\ uint{\isacharunderscore}maybe\ v\ {\isacharequal}\ {\isacharparenleft}\ unsigned{\isacharunderscore}of{\isacharunderscore}bits\ {\isacharparenleft}List{\isachardot}map\ {\isacharparenleft}{\isasymlambda}\ b{\isachardot}\ b{\isacharparenright}\ v{\isacharparenright}{\isacharparenright}{\isachardoublequoteclose}\isanewline
+\isanewline
+\isacommand{definition}\isamarkupfalse%
+\ uint{\isacharunderscore}fail\ \ {\isacharcolon}{\isacharcolon}\ {\isachardoublequoteopen}\ {\isacharprime}a\ Bitvector{\isacharunderscore}class\ {\isasymRightarrow}\ {\isacharprime}a\ {\isasymRightarrow}{\isacharparenleft}{\isacharprime}c{\isacharcomma}{\isacharparenleft}int{\isacharparenright}{\isacharcomma}{\isacharprime}b{\isacharparenright}monad\ {\isachardoublequoteclose}\ \ \isakeyword{where}\ \isanewline
+\ \ \ \ \ {\isachardoublequoteopen}\ uint{\isacharunderscore}fail\ dict{\isacharunderscore}Sail{\isadigit{2}}{\isacharunderscore}values{\isacharunderscore}Bitvector{\isacharunderscore}a\ v\ {\isacharequal}\ {\isacharparenleft}\ maybe{\isacharunderscore}fail\ {\isacharparenleft}{\isacharprime}{\isacharprime}uint{\isacharprime}{\isacharprime}{\isacharparenright}\ {\isacharparenleft}\isanewline
+\ \ {\isacharparenleft}unsigned{\isacharunderscore}method\ \ \ dict{\isacharunderscore}Sail{\isadigit{2}}{\isacharunderscore}values{\isacharunderscore}Bitvector{\isacharunderscore}a{\isacharparenright}\ v{\isacharparenright}{\isacharparenright}{\isachardoublequoteclose}\isanewline
+\isanewline
+\isacommand{definition}\isamarkupfalse%
+\ uint{\isacharunderscore}nondet\ \ {\isacharcolon}{\isacharcolon}\ {\isachardoublequoteopen}{\isacharparenleft}bitU{\isacharparenright}list\ {\isasymRightarrow}{\isacharparenleft}{\isacharprime}b{\isacharcomma}{\isacharparenleft}int{\isacharparenright}{\isacharcomma}{\isacharprime}a{\isacharparenright}monad\ {\isachardoublequoteclose}\ \ \isakeyword{where}\ \isanewline
+\ \ \ \ \ {\isachardoublequoteopen}\ uint{\isacharunderscore}nondet\ v\ {\isacharequal}\ {\isacharparenleft}\isanewline
+\ \ bools{\isacharunderscore}of{\isacharunderscore}bits{\isacharunderscore}nondet\ v\ {\isasymbind}\ {\isacharparenleft}{\isasymlambda}\ bs\ {\isachardot}\ \isanewline
+\ \ return\ {\isacharparenleft}int{\isacharunderscore}of{\isacharunderscore}bools\ False\ bs{\isacharparenright}{\isacharparenright}{\isacharparenright}{\isachardoublequoteclose}\isanewline
+\isanewline
+\isacommand{definition}\isamarkupfalse%
+\ uint\ \ {\isacharcolon}{\isacharcolon}\ {\isachardoublequoteopen}{\isacharparenleft}bitU{\isacharparenright}list\ {\isasymRightarrow}\ int\ {\isachardoublequoteclose}\ \ \isakeyword{where}\ \isanewline
+\ \ \ \ \ {\isachardoublequoteopen}\ uint\ v\ {\isacharequal}\ {\isacharparenleft}\ maybe{\isacharunderscore}failwith\ {\isacharparenleft}uint{\isacharunderscore}maybe\ v{\isacharparenright}{\isacharparenright}{\isachardoublequoteclose}\isanewline
+\isanewline
+\isanewline
+%
+\isamarkupcmt{\isa{val\ sint{\isacharunderscore}maybe\ {\isacharcolon}\ list\ bitU\ {\isacharminus}{\isachargreater}\ maybe\ integer}%
+}\isanewline
+\isacommand{definition}\isamarkupfalse%
+\ sint{\isacharunderscore}maybe\ \ {\isacharcolon}{\isacharcolon}\ {\isachardoublequoteopen}{\isacharparenleft}bitU{\isacharparenright}list\ {\isasymRightarrow}{\isacharparenleft}int{\isacharparenright}option\ {\isachardoublequoteclose}\ \ \isakeyword{where}\ \isanewline
+\ \ \ \ \ {\isachardoublequoteopen}\ sint{\isacharunderscore}maybe\ v\ {\isacharequal}\ {\isacharparenleft}\ signed{\isacharunderscore}of{\isacharunderscore}bits\ {\isacharparenleft}List{\isachardot}map\ {\isacharparenleft}{\isasymlambda}\ b{\isachardot}\ b{\isacharparenright}\ v{\isacharparenright}{\isacharparenright}{\isachardoublequoteclose}\isanewline
+\isanewline
+\isacommand{definition}\isamarkupfalse%
+\ sint{\isacharunderscore}fail\ \ {\isacharcolon}{\isacharcolon}\ {\isachardoublequoteopen}\ {\isacharprime}a\ Bitvector{\isacharunderscore}class\ {\isasymRightarrow}\ {\isacharprime}a\ {\isasymRightarrow}{\isacharparenleft}{\isacharprime}c{\isacharcomma}{\isacharparenleft}int{\isacharparenright}{\isacharcomma}{\isacharprime}b{\isacharparenright}monad\ {\isachardoublequoteclose}\ \ \isakeyword{where}\ \isanewline
+\ \ \ \ \ {\isachardoublequoteopen}\ sint{\isacharunderscore}fail\ dict{\isacharunderscore}Sail{\isadigit{2}}{\isacharunderscore}values{\isacharunderscore}Bitvector{\isacharunderscore}a\ v\ {\isacharequal}\ {\isacharparenleft}\ maybe{\isacharunderscore}fail\ {\isacharparenleft}{\isacharprime}{\isacharprime}sint{\isacharprime}{\isacharprime}{\isacharparenright}\ {\isacharparenleft}\isanewline
+\ \ {\isacharparenleft}signed{\isacharunderscore}method\ \ \ dict{\isacharunderscore}Sail{\isadigit{2}}{\isacharunderscore}values{\isacharunderscore}Bitvector{\isacharunderscore}a{\isacharparenright}\ v{\isacharparenright}{\isacharparenright}{\isachardoublequoteclose}\isanewline
+\isanewline
+\isacommand{definition}\isamarkupfalse%
+\ sint{\isacharunderscore}nondet\ \ {\isacharcolon}{\isacharcolon}\ {\isachardoublequoteopen}{\isacharparenleft}bitU{\isacharparenright}list\ {\isasymRightarrow}{\isacharparenleft}{\isacharprime}b{\isacharcomma}{\isacharparenleft}int{\isacharparenright}{\isacharcomma}{\isacharprime}a{\isacharparenright}monad\ {\isachardoublequoteclose}\ \ \isakeyword{where}\ \isanewline
+\ \ \ \ \ {\isachardoublequoteopen}\ sint{\isacharunderscore}nondet\ v\ {\isacharequal}\ {\isacharparenleft}\isanewline
+\ \ bools{\isacharunderscore}of{\isacharunderscore}bits{\isacharunderscore}nondet\ v\ {\isasymbind}\ {\isacharparenleft}{\isasymlambda}\ bs\ {\isachardot}\ \isanewline
+\ \ return\ {\isacharparenleft}int{\isacharunderscore}of{\isacharunderscore}bools\ True\ bs{\isacharparenright}{\isacharparenright}{\isacharparenright}{\isachardoublequoteclose}\isanewline
+\isanewline
+\isacommand{definition}\isamarkupfalse%
+\ sint\ \ {\isacharcolon}{\isacharcolon}\ {\isachardoublequoteopen}{\isacharparenleft}bitU{\isacharparenright}list\ {\isasymRightarrow}\ int\ {\isachardoublequoteclose}\ \ \isakeyword{where}\ \isanewline
+\ \ \ \ \ {\isachardoublequoteopen}\ sint\ v\ {\isacharequal}\ {\isacharparenleft}\ maybe{\isacharunderscore}failwith\ {\isacharparenleft}sint{\isacharunderscore}maybe\ v{\isacharparenright}{\isacharparenright}{\isachardoublequoteclose}\isanewline
+\isanewline
+\isanewline
+%
+\isamarkupcmt{\isa{val\ extz{\isacharunderscore}vec\ {\isacharcolon}\ integer\ {\isacharminus}{\isachargreater}\ list\ bitU\ {\isacharminus}{\isachargreater}\ list\ bitU}%
+}\isanewline
+\isacommand{definition}\isamarkupfalse%
+\ extz{\isacharunderscore}vec\ \ {\isacharcolon}{\isacharcolon}\ {\isachardoublequoteopen}\ int\ {\isasymRightarrow}{\isacharparenleft}bitU{\isacharparenright}list\ {\isasymRightarrow}{\isacharparenleft}bitU{\isacharparenright}list\ {\isachardoublequoteclose}\ \ \isakeyword{where}\ \isanewline
+\ \ \ \ \ {\isachardoublequoteopen}\ extz{\isacharunderscore}vec\ {\isacharequal}\ {\isacharparenleft}\ \isanewline
+\ \ extz{\isacharunderscore}bv\isanewline
+\ \ \ \ {\isacharparenleft}instance{\isacharunderscore}Sail{\isadigit{2}}{\isacharunderscore}values{\isacharunderscore}Bitvector{\isacharunderscore}list{\isacharunderscore}dict\isanewline
+\ \ \ \ \ \ \ instance{\isacharunderscore}Sail{\isadigit{2}}{\isacharunderscore}values{\isacharunderscore}BitU{\isacharunderscore}Sail{\isadigit{2}}{\isacharunderscore}values{\isacharunderscore}bitU{\isacharunderscore}dict{\isacharparenright}\ {\isacharparenright}{\isachardoublequoteclose}\isanewline
+\isanewline
+\isanewline
+%
+\isamarkupcmt{\isa{val\ exts{\isacharunderscore}vec\ {\isacharcolon}\ integer\ {\isacharminus}{\isachargreater}\ list\ bitU\ {\isacharminus}{\isachargreater}\ list\ bitU}%
+}\isanewline
+\isacommand{definition}\isamarkupfalse%
+\ exts{\isacharunderscore}vec\ \ {\isacharcolon}{\isacharcolon}\ {\isachardoublequoteopen}\ int\ {\isasymRightarrow}{\isacharparenleft}bitU{\isacharparenright}list\ {\isasymRightarrow}{\isacharparenleft}bitU{\isacharparenright}list\ {\isachardoublequoteclose}\ \ \isakeyword{where}\ \isanewline
+\ \ \ \ \ {\isachardoublequoteopen}\ exts{\isacharunderscore}vec\ {\isacharequal}\ {\isacharparenleft}\ \isanewline
+\ \ exts{\isacharunderscore}bv\isanewline
+\ \ \ \ {\isacharparenleft}instance{\isacharunderscore}Sail{\isadigit{2}}{\isacharunderscore}values{\isacharunderscore}Bitvector{\isacharunderscore}list{\isacharunderscore}dict\isanewline
+\ \ \ \ \ \ \ instance{\isacharunderscore}Sail{\isadigit{2}}{\isacharunderscore}values{\isacharunderscore}BitU{\isacharunderscore}Sail{\isadigit{2}}{\isacharunderscore}values{\isacharunderscore}bitU{\isacharunderscore}dict{\isacharparenright}\ {\isacharparenright}{\isachardoublequoteclose}\isanewline
+\isanewline
+\isanewline
+%
+\isamarkupcmt{\isa{val\ zero{\isacharunderscore}extend\ {\isacharcolon}\ list\ bitU\ {\isacharminus}{\isachargreater}\ integer\ {\isacharminus}{\isachargreater}\ list\ bitU}%
+}\isanewline
+\isacommand{definition}\isamarkupfalse%
+\ zero{\isacharunderscore}extend\ \ {\isacharcolon}{\isacharcolon}\ {\isachardoublequoteopen}{\isacharparenleft}bitU{\isacharparenright}list\ {\isasymRightarrow}\ int\ {\isasymRightarrow}{\isacharparenleft}bitU{\isacharparenright}list\ {\isachardoublequoteclose}\ \ \isakeyword{where}\ \isanewline
+\ \ \ \ \ {\isachardoublequoteopen}\ zero{\isacharunderscore}extend\ bits\ len\ {\isacharequal}\ {\isacharparenleft}\ extz{\isacharunderscore}bits\ len\ bits\ {\isacharparenright}{\isachardoublequoteclose}\isanewline
+\isanewline
+\isanewline
+%
+\isamarkupcmt{\isa{val\ sign{\isacharunderscore}extend\ {\isacharcolon}\ list\ bitU\ {\isacharminus}{\isachargreater}\ integer\ {\isacharminus}{\isachargreater}\ list\ bitU}%
+}\isanewline
+\isacommand{definition}\isamarkupfalse%
+\ sign{\isacharunderscore}extend\ \ {\isacharcolon}{\isacharcolon}\ {\isachardoublequoteopen}{\isacharparenleft}bitU{\isacharparenright}list\ {\isasymRightarrow}\ int\ {\isasymRightarrow}{\isacharparenleft}bitU{\isacharparenright}list\ {\isachardoublequoteclose}\ \ \isakeyword{where}\ \isanewline
+\ \ \ \ \ {\isachardoublequoteopen}\ sign{\isacharunderscore}extend\ bits\ len\ {\isacharequal}\ {\isacharparenleft}\ exts{\isacharunderscore}bits\ len\ bits\ {\isacharparenright}{\isachardoublequoteclose}\isanewline
+\isanewline
+\isanewline
+%
+\isamarkupcmt{\isa{val\ zeros\ {\isacharcolon}\ integer\ {\isacharminus}{\isachargreater}\ list\ bitU}%
+}\isanewline
+\isacommand{definition}\isamarkupfalse%
+\ zeros\ \ {\isacharcolon}{\isacharcolon}\ {\isachardoublequoteopen}\ int\ {\isasymRightarrow}{\isacharparenleft}bitU{\isacharparenright}list\ {\isachardoublequoteclose}\ \ \isakeyword{where}\ \isanewline
+\ \ \ \ \ {\isachardoublequoteopen}\ zeros\ len\ {\isacharequal}\ {\isacharparenleft}\ repeat\ {\isacharbrackleft}B{\isadigit{0}}{\isacharbrackright}\ len\ {\isacharparenright}{\isachardoublequoteclose}\isanewline
+\isanewline
+\isanewline
+%
+\isamarkupcmt{\isa{val\ vector{\isacharunderscore}truncate\ {\isacharcolon}\ list\ bitU\ {\isacharminus}{\isachargreater}\ integer\ {\isacharminus}{\isachargreater}\ list\ bitU}%
+}\isanewline
+\isacommand{definition}\isamarkupfalse%
+\ vector{\isacharunderscore}truncate\ \ {\isacharcolon}{\isacharcolon}\ {\isachardoublequoteopen}{\isacharparenleft}bitU{\isacharparenright}list\ {\isasymRightarrow}\ int\ {\isasymRightarrow}{\isacharparenleft}bitU{\isacharparenright}list\ {\isachardoublequoteclose}\ \ \isakeyword{where}\ \isanewline
+\ \ \ \ \ {\isachardoublequoteopen}\ vector{\isacharunderscore}truncate\ bs\ len\ {\isacharequal}\ {\isacharparenleft}\ extz{\isacharunderscore}bv\ \isanewline
+\ \ {\isacharparenleft}instance{\isacharunderscore}Sail{\isadigit{2}}{\isacharunderscore}values{\isacharunderscore}Bitvector{\isacharunderscore}list{\isacharunderscore}dict\isanewline
+\ \ \ \ \ instance{\isacharunderscore}Sail{\isadigit{2}}{\isacharunderscore}values{\isacharunderscore}BitU{\isacharunderscore}Sail{\isadigit{2}}{\isacharunderscore}values{\isacharunderscore}bitU{\isacharunderscore}dict{\isacharparenright}\ len\ bs\ {\isacharparenright}{\isachardoublequoteclose}\isanewline
+\isanewline
+\isanewline
+%
+\isamarkupcmt{\isa{val\ vec{\isacharunderscore}of{\isacharunderscore}bits{\isacharunderscore}maybe\ \ \ \ {\isacharcolon}\ list\ bitU\ {\isacharminus}{\isachargreater}\ maybe\ {\isacharparenleft}list\ bitU{\isacharparenright}}%
+}\isanewline
+%
+\isamarkupcmt{\isa{val\ vec{\isacharunderscore}of{\isacharunderscore}bits{\isacharunderscore}fail\ \ \ \ \ {\isacharcolon}\ forall\ {\isacharprime}rv\ {\isacharprime}e{\isachardot}\ list\ bitU\ {\isacharminus}{\isachargreater}\ monad\ {\isacharprime}rv\ {\isacharparenleft}list\ bitU{\isacharparenright}\ {\isacharprime}e}%
+}\isanewline
+%
+\isamarkupcmt{\isa{val\ vec{\isacharunderscore}of{\isacharunderscore}bits{\isacharunderscore}nondet\ \ \ {\isacharcolon}\ forall\ {\isacharprime}rv\ {\isacharprime}e{\isachardot}\ list\ bitU\ {\isacharminus}{\isachargreater}\ monad\ {\isacharprime}rv\ {\isacharparenleft}list\ bitU{\isacharparenright}\ {\isacharprime}e}%
+}\isanewline
+%
+\isamarkupcmt{\isa{val\ vec{\isacharunderscore}of{\isacharunderscore}bits{\isacharunderscore}failwith\ {\isacharcolon}\ list\ bitU\ {\isacharminus}{\isachargreater}\ list\ bitU}%
+}\isanewline
+%
+\isamarkupcmt{\isa{val\ vec{\isacharunderscore}of{\isacharunderscore}bits\ \ \ \ \ \ \ \ \ \ {\isacharcolon}\ list\ bitU\ {\isacharminus}{\isachargreater}\ list\ bitU}%
+}\isanewline
+\isanewline
+%
+\isamarkupcmt{\isa{val\ access{\isacharunderscore}vec{\isacharunderscore}inc\ {\isacharcolon}\ list\ bitU\ {\isacharminus}{\isachargreater}\ integer\ {\isacharminus}{\isachargreater}\ bitU}%
+}\isanewline
+\isacommand{definition}\isamarkupfalse%
+\ access{\isacharunderscore}vec{\isacharunderscore}inc\ \ {\isacharcolon}{\isacharcolon}\ {\isachardoublequoteopen}{\isacharparenleft}bitU{\isacharparenright}list\ {\isasymRightarrow}\ int\ {\isasymRightarrow}\ bitU\ {\isachardoublequoteclose}\ \ \isakeyword{where}\ \isanewline
+\ \ \ \ \ {\isachardoublequoteopen}\ access{\isacharunderscore}vec{\isacharunderscore}inc\ {\isacharequal}\ {\isacharparenleft}\ \isanewline
+\ \ access{\isacharunderscore}bv{\isacharunderscore}inc\isanewline
+\ \ \ \ {\isacharparenleft}instance{\isacharunderscore}Sail{\isadigit{2}}{\isacharunderscore}values{\isacharunderscore}Bitvector{\isacharunderscore}list{\isacharunderscore}dict\isanewline
+\ \ \ \ \ \ \ instance{\isacharunderscore}Sail{\isadigit{2}}{\isacharunderscore}values{\isacharunderscore}BitU{\isacharunderscore}Sail{\isadigit{2}}{\isacharunderscore}values{\isacharunderscore}bitU{\isacharunderscore}dict{\isacharparenright}\ {\isacharparenright}{\isachardoublequoteclose}\isanewline
+\isanewline
+\isanewline
+%
+\isamarkupcmt{\isa{val\ access{\isacharunderscore}vec{\isacharunderscore}dec\ {\isacharcolon}\ list\ bitU\ {\isacharminus}{\isachargreater}\ integer\ {\isacharminus}{\isachargreater}\ bitU}%
+}\isanewline
+\isacommand{definition}\isamarkupfalse%
+\ access{\isacharunderscore}vec{\isacharunderscore}dec\ \ {\isacharcolon}{\isacharcolon}\ {\isachardoublequoteopen}{\isacharparenleft}bitU{\isacharparenright}list\ {\isasymRightarrow}\ int\ {\isasymRightarrow}\ bitU\ {\isachardoublequoteclose}\ \ \isakeyword{where}\ \isanewline
+\ \ \ \ \ {\isachardoublequoteopen}\ access{\isacharunderscore}vec{\isacharunderscore}dec\ {\isacharequal}\ {\isacharparenleft}\ \isanewline
+\ \ access{\isacharunderscore}bv{\isacharunderscore}dec\isanewline
+\ \ \ \ {\isacharparenleft}instance{\isacharunderscore}Sail{\isadigit{2}}{\isacharunderscore}values{\isacharunderscore}Bitvector{\isacharunderscore}list{\isacharunderscore}dict\isanewline
+\ \ \ \ \ \ \ instance{\isacharunderscore}Sail{\isadigit{2}}{\isacharunderscore}values{\isacharunderscore}BitU{\isacharunderscore}Sail{\isadigit{2}}{\isacharunderscore}values{\isacharunderscore}bitU{\isacharunderscore}dict{\isacharparenright}\ {\isacharparenright}{\isachardoublequoteclose}\isanewline
+\isanewline
+\isanewline
+%
+\isamarkupcmt{\isa{val\ update{\isacharunderscore}vec{\isacharunderscore}inc\ {\isacharcolon}\ list\ bitU\ {\isacharminus}{\isachargreater}\ integer\ {\isacharminus}{\isachargreater}\ bitU\ {\isacharminus}{\isachargreater}\ list\ bitU}%
+}\isanewline
+\isacommand{definition}\isamarkupfalse%
+\ update{\isacharunderscore}vec{\isacharunderscore}inc\ \ {\isacharcolon}{\isacharcolon}\ {\isachardoublequoteopen}{\isacharparenleft}bitU{\isacharparenright}list\ {\isasymRightarrow}\ int\ {\isasymRightarrow}\ bitU\ {\isasymRightarrow}{\isacharparenleft}bitU{\isacharparenright}list\ {\isachardoublequoteclose}\ \ \isakeyword{where}\ \isanewline
+\ \ \ \ \ {\isachardoublequoteopen}\ update{\isacharunderscore}vec{\isacharunderscore}inc\ {\isacharequal}\ {\isacharparenleft}\ \isanewline
+\ \ update{\isacharunderscore}bv{\isacharunderscore}inc\isanewline
+\ \ \ \ {\isacharparenleft}instance{\isacharunderscore}Sail{\isadigit{2}}{\isacharunderscore}values{\isacharunderscore}Bitvector{\isacharunderscore}list{\isacharunderscore}dict\isanewline
+\ \ \ \ \ \ \ instance{\isacharunderscore}Sail{\isadigit{2}}{\isacharunderscore}values{\isacharunderscore}BitU{\isacharunderscore}Sail{\isadigit{2}}{\isacharunderscore}values{\isacharunderscore}bitU{\isacharunderscore}dict{\isacharparenright}\ {\isacharparenright}{\isachardoublequoteclose}\isanewline
+\isanewline
+\isacommand{definition}\isamarkupfalse%
+\ update{\isacharunderscore}vec{\isacharunderscore}inc{\isacharunderscore}maybe\ \ {\isacharcolon}{\isacharcolon}\ {\isachardoublequoteopen}{\isacharparenleft}bitU{\isacharparenright}list\ {\isasymRightarrow}\ int\ {\isasymRightarrow}\ bitU\ {\isasymRightarrow}{\isacharparenleft}{\isacharparenleft}bitU{\isacharparenright}list{\isacharparenright}option\ {\isachardoublequoteclose}\ \ \isakeyword{where}\ \isanewline
+\ \ \ \ \ {\isachardoublequoteopen}\ update{\isacharunderscore}vec{\isacharunderscore}inc{\isacharunderscore}maybe\ v\ i\ b\ {\isacharequal}\ {\isacharparenleft}\ Some\ {\isacharparenleft}update{\isacharunderscore}vec{\isacharunderscore}inc\ v\ i\ b{\isacharparenright}{\isacharparenright}{\isachardoublequoteclose}\isanewline
+\isanewline
+\isacommand{definition}\isamarkupfalse%
+\ update{\isacharunderscore}vec{\isacharunderscore}inc{\isacharunderscore}fail\ \ {\isacharcolon}{\isacharcolon}\ {\isachardoublequoteopen}{\isacharparenleft}bitU{\isacharparenright}list\ {\isasymRightarrow}\ int\ {\isasymRightarrow}\ bitU\ {\isasymRightarrow}{\isacharparenleft}{\isacharprime}b{\isacharcomma}{\isacharparenleft}{\isacharparenleft}bitU{\isacharparenright}list{\isacharparenright}{\isacharcomma}{\isacharprime}a{\isacharparenright}monad\ {\isachardoublequoteclose}\ \ \isakeyword{where}\ \isanewline
+\ \ \ \ \ {\isachardoublequoteopen}\ update{\isacharunderscore}vec{\isacharunderscore}inc{\isacharunderscore}fail\ v\ i\ b\ {\isacharequal}\ {\isacharparenleft}\ return\ {\isacharparenleft}update{\isacharunderscore}vec{\isacharunderscore}inc\ v\ i\ b{\isacharparenright}{\isacharparenright}{\isachardoublequoteclose}\isanewline
+\isanewline
+\isacommand{definition}\isamarkupfalse%
+\ update{\isacharunderscore}vec{\isacharunderscore}inc{\isacharunderscore}nondet\ \ {\isacharcolon}{\isacharcolon}\ {\isachardoublequoteopen}{\isacharparenleft}bitU{\isacharparenright}list\ {\isasymRightarrow}\ int\ {\isasymRightarrow}\ bitU\ {\isasymRightarrow}{\isacharparenleft}{\isacharprime}b{\isacharcomma}{\isacharparenleft}{\isacharparenleft}bitU{\isacharparenright}list{\isacharparenright}{\isacharcomma}{\isacharprime}a{\isacharparenright}monad\ {\isachardoublequoteclose}\ \ \isakeyword{where}\ \isanewline
+\ \ \ \ \ {\isachardoublequoteopen}\ update{\isacharunderscore}vec{\isacharunderscore}inc{\isacharunderscore}nondet\ v\ i\ b\ {\isacharequal}\ {\isacharparenleft}\ return\ {\isacharparenleft}update{\isacharunderscore}vec{\isacharunderscore}inc\ v\ i\ b{\isacharparenright}{\isacharparenright}{\isachardoublequoteclose}\isanewline
+\isanewline
+\isanewline
+%
+\isamarkupcmt{\isa{val\ update{\isacharunderscore}vec{\isacharunderscore}dec\ {\isacharcolon}\ list\ bitU\ {\isacharminus}{\isachargreater}\ integer\ {\isacharminus}{\isachargreater}\ bitU\ {\isacharminus}{\isachargreater}\ list\ bitU}%
+}\isanewline
+\isacommand{definition}\isamarkupfalse%
+\ update{\isacharunderscore}vec{\isacharunderscore}dec\ \ {\isacharcolon}{\isacharcolon}\ {\isachardoublequoteopen}{\isacharparenleft}bitU{\isacharparenright}list\ {\isasymRightarrow}\ int\ {\isasymRightarrow}\ bitU\ {\isasymRightarrow}{\isacharparenleft}bitU{\isacharparenright}list\ {\isachardoublequoteclose}\ \ \isakeyword{where}\ \isanewline
+\ \ \ \ \ {\isachardoublequoteopen}\ update{\isacharunderscore}vec{\isacharunderscore}dec\ {\isacharequal}\ {\isacharparenleft}\ \isanewline
+\ \ update{\isacharunderscore}bv{\isacharunderscore}dec\isanewline
+\ \ \ \ {\isacharparenleft}instance{\isacharunderscore}Sail{\isadigit{2}}{\isacharunderscore}values{\isacharunderscore}Bitvector{\isacharunderscore}list{\isacharunderscore}dict\isanewline
+\ \ \ \ \ \ \ instance{\isacharunderscore}Sail{\isadigit{2}}{\isacharunderscore}values{\isacharunderscore}BitU{\isacharunderscore}Sail{\isadigit{2}}{\isacharunderscore}values{\isacharunderscore}bitU{\isacharunderscore}dict{\isacharparenright}\ {\isacharparenright}{\isachardoublequoteclose}\isanewline
+\isanewline
+\isacommand{definition}\isamarkupfalse%
+\ update{\isacharunderscore}vec{\isacharunderscore}dec{\isacharunderscore}maybe\ \ {\isacharcolon}{\isacharcolon}\ {\isachardoublequoteopen}{\isacharparenleft}bitU{\isacharparenright}list\ {\isasymRightarrow}\ int\ {\isasymRightarrow}\ bitU\ {\isasymRightarrow}{\isacharparenleft}{\isacharparenleft}bitU{\isacharparenright}list{\isacharparenright}option\ {\isachardoublequoteclose}\ \ \isakeyword{where}\ \isanewline
+\ \ \ \ \ {\isachardoublequoteopen}\ update{\isacharunderscore}vec{\isacharunderscore}dec{\isacharunderscore}maybe\ v\ i\ b\ {\isacharequal}\ {\isacharparenleft}\ Some\ {\isacharparenleft}update{\isacharunderscore}vec{\isacharunderscore}dec\ v\ i\ b{\isacharparenright}{\isacharparenright}{\isachardoublequoteclose}\isanewline
+\isanewline
+\isacommand{definition}\isamarkupfalse%
+\ update{\isacharunderscore}vec{\isacharunderscore}dec{\isacharunderscore}fail\ \ {\isacharcolon}{\isacharcolon}\ {\isachardoublequoteopen}{\isacharparenleft}bitU{\isacharparenright}list\ {\isasymRightarrow}\ int\ {\isasymRightarrow}\ bitU\ {\isasymRightarrow}{\isacharparenleft}{\isacharprime}b{\isacharcomma}{\isacharparenleft}{\isacharparenleft}bitU{\isacharparenright}list{\isacharparenright}{\isacharcomma}{\isacharprime}a{\isacharparenright}monad\ {\isachardoublequoteclose}\ \ \isakeyword{where}\ \isanewline
+\ \ \ \ \ {\isachardoublequoteopen}\ update{\isacharunderscore}vec{\isacharunderscore}dec{\isacharunderscore}fail\ v\ i\ b\ {\isacharequal}\ {\isacharparenleft}\ return\ {\isacharparenleft}update{\isacharunderscore}vec{\isacharunderscore}dec\ v\ i\ b{\isacharparenright}{\isacharparenright}{\isachardoublequoteclose}\isanewline
+\isanewline
+\isacommand{definition}\isamarkupfalse%
+\ update{\isacharunderscore}vec{\isacharunderscore}dec{\isacharunderscore}nondet\ \ {\isacharcolon}{\isacharcolon}\ {\isachardoublequoteopen}{\isacharparenleft}bitU{\isacharparenright}list\ {\isasymRightarrow}\ int\ {\isasymRightarrow}\ bitU\ {\isasymRightarrow}{\isacharparenleft}{\isacharprime}b{\isacharcomma}{\isacharparenleft}{\isacharparenleft}bitU{\isacharparenright}list{\isacharparenright}{\isacharcomma}{\isacharprime}a{\isacharparenright}monad\ {\isachardoublequoteclose}\ \ \isakeyword{where}\ \isanewline
+\ \ \ \ \ {\isachardoublequoteopen}\ update{\isacharunderscore}vec{\isacharunderscore}dec{\isacharunderscore}nondet\ v\ i\ b\ {\isacharequal}\ {\isacharparenleft}\ return\ {\isacharparenleft}update{\isacharunderscore}vec{\isacharunderscore}dec\ v\ i\ b{\isacharparenright}{\isacharparenright}{\isachardoublequoteclose}\isanewline
+\isanewline
+\isanewline
+%
+\isamarkupcmt{\isa{val\ subrange{\isacharunderscore}vec{\isacharunderscore}inc\ {\isacharcolon}\ list\ bitU\ {\isacharminus}{\isachargreater}\ integer\ {\isacharminus}{\isachargreater}\ integer\ {\isacharminus}{\isachargreater}\ list\ bitU}%
+}\isanewline
+\isacommand{definition}\isamarkupfalse%
+\ subrange{\isacharunderscore}vec{\isacharunderscore}inc\ \ {\isacharcolon}{\isacharcolon}\ {\isachardoublequoteopen}{\isacharparenleft}bitU{\isacharparenright}list\ {\isasymRightarrow}\ int\ {\isasymRightarrow}\ int\ {\isasymRightarrow}{\isacharparenleft}bitU{\isacharparenright}list\ {\isachardoublequoteclose}\ \ \isakeyword{where}\ \isanewline
+\ \ \ \ \ {\isachardoublequoteopen}\ subrange{\isacharunderscore}vec{\isacharunderscore}inc\ {\isacharequal}\ {\isacharparenleft}\ \isanewline
+\ \ subrange{\isacharunderscore}bv{\isacharunderscore}inc\isanewline
+\ \ \ \ {\isacharparenleft}instance{\isacharunderscore}Sail{\isadigit{2}}{\isacharunderscore}values{\isacharunderscore}Bitvector{\isacharunderscore}list{\isacharunderscore}dict\isanewline
+\ \ \ \ \ \ \ instance{\isacharunderscore}Sail{\isadigit{2}}{\isacharunderscore}values{\isacharunderscore}BitU{\isacharunderscore}Sail{\isadigit{2}}{\isacharunderscore}values{\isacharunderscore}bitU{\isacharunderscore}dict{\isacharparenright}\ {\isacharparenright}{\isachardoublequoteclose}\isanewline
+\isanewline
+\isanewline
+%
+\isamarkupcmt{\isa{val\ subrange{\isacharunderscore}vec{\isacharunderscore}dec\ {\isacharcolon}\ list\ bitU\ {\isacharminus}{\isachargreater}\ integer\ {\isacharminus}{\isachargreater}\ integer\ {\isacharminus}{\isachargreater}\ list\ bitU}%
+}\isanewline
+\isacommand{definition}\isamarkupfalse%
+\ subrange{\isacharunderscore}vec{\isacharunderscore}dec\ \ {\isacharcolon}{\isacharcolon}\ {\isachardoublequoteopen}{\isacharparenleft}bitU{\isacharparenright}list\ {\isasymRightarrow}\ int\ {\isasymRightarrow}\ int\ {\isasymRightarrow}{\isacharparenleft}bitU{\isacharparenright}list\ {\isachardoublequoteclose}\ \ \isakeyword{where}\ \isanewline
+\ \ \ \ \ {\isachardoublequoteopen}\ subrange{\isacharunderscore}vec{\isacharunderscore}dec\ {\isacharequal}\ {\isacharparenleft}\ \isanewline
+\ \ subrange{\isacharunderscore}bv{\isacharunderscore}dec\isanewline
+\ \ \ \ {\isacharparenleft}instance{\isacharunderscore}Sail{\isadigit{2}}{\isacharunderscore}values{\isacharunderscore}Bitvector{\isacharunderscore}list{\isacharunderscore}dict\isanewline
+\ \ \ \ \ \ \ instance{\isacharunderscore}Sail{\isadigit{2}}{\isacharunderscore}values{\isacharunderscore}BitU{\isacharunderscore}Sail{\isadigit{2}}{\isacharunderscore}values{\isacharunderscore}bitU{\isacharunderscore}dict{\isacharparenright}\ {\isacharparenright}{\isachardoublequoteclose}\isanewline
+\isanewline
+\isanewline
+%
+\isamarkupcmt{\isa{val\ update{\isacharunderscore}subrange{\isacharunderscore}vec{\isacharunderscore}inc\ {\isacharcolon}\ list\ bitU\ {\isacharminus}{\isachargreater}\ integer\ {\isacharminus}{\isachargreater}\ integer\ {\isacharminus}{\isachargreater}\ list\ bitU\ {\isacharminus}{\isachargreater}\ list\ bitU}%
+}\isanewline
+\isacommand{definition}\isamarkupfalse%
+\ update{\isacharunderscore}subrange{\isacharunderscore}vec{\isacharunderscore}inc\ \ {\isacharcolon}{\isacharcolon}\ {\isachardoublequoteopen}{\isacharparenleft}bitU{\isacharparenright}list\ {\isasymRightarrow}\ int\ {\isasymRightarrow}\ int\ {\isasymRightarrow}{\isacharparenleft}bitU{\isacharparenright}list\ {\isasymRightarrow}{\isacharparenleft}bitU{\isacharparenright}list\ {\isachardoublequoteclose}\ \ \isakeyword{where}\ \isanewline
+\ \ \ \ \ {\isachardoublequoteopen}\ update{\isacharunderscore}subrange{\isacharunderscore}vec{\isacharunderscore}inc\ {\isacharequal}\ {\isacharparenleft}\ \isanewline
+\ \ update{\isacharunderscore}subrange{\isacharunderscore}bv{\isacharunderscore}inc\isanewline
+\ \ \ \ {\isacharparenleft}instance{\isacharunderscore}Sail{\isadigit{2}}{\isacharunderscore}values{\isacharunderscore}Bitvector{\isacharunderscore}list{\isacharunderscore}dict\isanewline
+\ \ \ \ \ \ \ instance{\isacharunderscore}Sail{\isadigit{2}}{\isacharunderscore}values{\isacharunderscore}BitU{\isacharunderscore}Sail{\isadigit{2}}{\isacharunderscore}values{\isacharunderscore}bitU{\isacharunderscore}dict{\isacharparenright}\isanewline
+\ \ \ \ {\isacharparenleft}instance{\isacharunderscore}Sail{\isadigit{2}}{\isacharunderscore}values{\isacharunderscore}Bitvector{\isacharunderscore}list{\isacharunderscore}dict\isanewline
+\ \ \ \ \ \ \ instance{\isacharunderscore}Sail{\isadigit{2}}{\isacharunderscore}values{\isacharunderscore}BitU{\isacharunderscore}Sail{\isadigit{2}}{\isacharunderscore}values{\isacharunderscore}bitU{\isacharunderscore}dict{\isacharparenright}\ {\isacharparenright}{\isachardoublequoteclose}\isanewline
+\isanewline
+\isanewline
+%
+\isamarkupcmt{\isa{val\ update{\isacharunderscore}subrange{\isacharunderscore}vec{\isacharunderscore}dec\ {\isacharcolon}\ list\ bitU\ {\isacharminus}{\isachargreater}\ integer\ {\isacharminus}{\isachargreater}\ integer\ {\isacharminus}{\isachargreater}\ list\ bitU\ {\isacharminus}{\isachargreater}\ list\ bitU}%
+}\isanewline
+\isacommand{definition}\isamarkupfalse%
+\ update{\isacharunderscore}subrange{\isacharunderscore}vec{\isacharunderscore}dec\ \ {\isacharcolon}{\isacharcolon}\ {\isachardoublequoteopen}{\isacharparenleft}bitU{\isacharparenright}list\ {\isasymRightarrow}\ int\ {\isasymRightarrow}\ int\ {\isasymRightarrow}{\isacharparenleft}bitU{\isacharparenright}list\ {\isasymRightarrow}{\isacharparenleft}bitU{\isacharparenright}list\ {\isachardoublequoteclose}\ \ \isakeyword{where}\ \isanewline
+\ \ \ \ \ {\isachardoublequoteopen}\ update{\isacharunderscore}subrange{\isacharunderscore}vec{\isacharunderscore}dec\ {\isacharequal}\ {\isacharparenleft}\ \isanewline
+\ \ update{\isacharunderscore}subrange{\isacharunderscore}bv{\isacharunderscore}dec\isanewline
+\ \ \ \ {\isacharparenleft}instance{\isacharunderscore}Sail{\isadigit{2}}{\isacharunderscore}values{\isacharunderscore}Bitvector{\isacharunderscore}list{\isacharunderscore}dict\isanewline
+\ \ \ \ \ \ \ instance{\isacharunderscore}Sail{\isadigit{2}}{\isacharunderscore}values{\isacharunderscore}BitU{\isacharunderscore}Sail{\isadigit{2}}{\isacharunderscore}values{\isacharunderscore}bitU{\isacharunderscore}dict{\isacharparenright}\isanewline
+\ \ \ \ {\isacharparenleft}instance{\isacharunderscore}Sail{\isadigit{2}}{\isacharunderscore}values{\isacharunderscore}Bitvector{\isacharunderscore}list{\isacharunderscore}dict\isanewline
+\ \ \ \ \ \ \ instance{\isacharunderscore}Sail{\isadigit{2}}{\isacharunderscore}values{\isacharunderscore}BitU{\isacharunderscore}Sail{\isadigit{2}}{\isacharunderscore}values{\isacharunderscore}bitU{\isacharunderscore}dict{\isacharparenright}\ {\isacharparenright}{\isachardoublequoteclose}\isanewline
+\isanewline
+\isanewline
+%
+\isamarkupcmt{\isa{val\ concat{\isacharunderscore}vec\ {\isacharcolon}\ list\ bitU\ {\isacharminus}{\isachargreater}\ list\ bitU\ {\isacharminus}{\isachargreater}\ list\ bitU}%
+}\isanewline
+\isacommand{definition}\isamarkupfalse%
+\ concat{\isacharunderscore}vec\ \ {\isacharcolon}{\isacharcolon}\ {\isachardoublequoteopen}{\isacharparenleft}bitU{\isacharparenright}list\ {\isasymRightarrow}{\isacharparenleft}bitU{\isacharparenright}list\ {\isasymRightarrow}{\isacharparenleft}bitU{\isacharparenright}list\ {\isachardoublequoteclose}\ \ \isakeyword{where}\ \isanewline
+\ \ \ \ \ {\isachardoublequoteopen}\ concat{\isacharunderscore}vec\ {\isacharequal}\ {\isacharparenleft}\ \isanewline
+\ \ concat{\isacharunderscore}bv\isanewline
+\ \ \ \ {\isacharparenleft}instance{\isacharunderscore}Sail{\isadigit{2}}{\isacharunderscore}values{\isacharunderscore}Bitvector{\isacharunderscore}list{\isacharunderscore}dict\isanewline
+\ \ \ \ \ \ \ instance{\isacharunderscore}Sail{\isadigit{2}}{\isacharunderscore}values{\isacharunderscore}BitU{\isacharunderscore}Sail{\isadigit{2}}{\isacharunderscore}values{\isacharunderscore}bitU{\isacharunderscore}dict{\isacharparenright}\isanewline
+\ \ \ \ {\isacharparenleft}instance{\isacharunderscore}Sail{\isadigit{2}}{\isacharunderscore}values{\isacharunderscore}Bitvector{\isacharunderscore}list{\isacharunderscore}dict\isanewline
+\ \ \ \ \ \ \ instance{\isacharunderscore}Sail{\isadigit{2}}{\isacharunderscore}values{\isacharunderscore}BitU{\isacharunderscore}Sail{\isadigit{2}}{\isacharunderscore}values{\isacharunderscore}bitU{\isacharunderscore}dict{\isacharparenright}\ {\isacharparenright}{\isachardoublequoteclose}\isanewline
+\isanewline
+\isanewline
+%
+\isamarkupcmt{\isa{val\ cons{\isacharunderscore}vec\ {\isacharcolon}\ bitU\ {\isacharminus}{\isachargreater}\ list\ bitU\ {\isacharminus}{\isachargreater}\ list\ bitU}%
+}\isanewline
+\isacommand{definition}\isamarkupfalse%
+\ cons{\isacharunderscore}vec\ \ {\isacharcolon}{\isacharcolon}\ {\isachardoublequoteopen}\ bitU\ {\isasymRightarrow}{\isacharparenleft}bitU{\isacharparenright}list\ {\isasymRightarrow}{\isacharparenleft}bitU{\isacharparenright}list\ {\isachardoublequoteclose}\ \ \isakeyword{where}\ \isanewline
+\ \ \ \ \ {\isachardoublequoteopen}\ cons{\isacharunderscore}vec\ {\isacharequal}\ {\isacharparenleft}\ \isanewline
+\ \ cons{\isacharunderscore}bv\isanewline
+\ \ \ \ {\isacharparenleft}instance{\isacharunderscore}Sail{\isadigit{2}}{\isacharunderscore}values{\isacharunderscore}Bitvector{\isacharunderscore}list{\isacharunderscore}dict\isanewline
+\ \ \ \ \ \ \ instance{\isacharunderscore}Sail{\isadigit{2}}{\isacharunderscore}values{\isacharunderscore}BitU{\isacharunderscore}Sail{\isadigit{2}}{\isacharunderscore}values{\isacharunderscore}bitU{\isacharunderscore}dict{\isacharparenright}\ {\isacharparenright}{\isachardoublequoteclose}\isanewline
+\isanewline
+\isacommand{definition}\isamarkupfalse%
+\ cons{\isacharunderscore}vec{\isacharunderscore}maybe\ \ {\isacharcolon}{\isacharcolon}\ {\isachardoublequoteopen}\ bitU\ {\isasymRightarrow}{\isacharparenleft}bitU{\isacharparenright}list\ {\isasymRightarrow}{\isacharparenleft}{\isacharparenleft}bitU{\isacharparenright}list{\isacharparenright}option\ {\isachardoublequoteclose}\ \ \isakeyword{where}\ \isanewline
+\ \ \ \ \ {\isachardoublequoteopen}\ cons{\isacharunderscore}vec{\isacharunderscore}maybe\ b\ v\ {\isacharequal}\ {\isacharparenleft}\ Some\ {\isacharparenleft}cons{\isacharunderscore}vec\ b\ v{\isacharparenright}{\isacharparenright}{\isachardoublequoteclose}\isanewline
+\isanewline
+\isacommand{definition}\isamarkupfalse%
+\ cons{\isacharunderscore}vec{\isacharunderscore}fail\ \ {\isacharcolon}{\isacharcolon}\ {\isachardoublequoteopen}\ bitU\ {\isasymRightarrow}{\isacharparenleft}bitU{\isacharparenright}list\ {\isasymRightarrow}{\isacharparenleft}{\isacharprime}b{\isacharcomma}{\isacharparenleft}{\isacharparenleft}bitU{\isacharparenright}list{\isacharparenright}{\isacharcomma}{\isacharprime}a{\isacharparenright}monad\ {\isachardoublequoteclose}\ \ \isakeyword{where}\ \isanewline
+\ \ \ \ \ {\isachardoublequoteopen}\ cons{\isacharunderscore}vec{\isacharunderscore}fail\ b\ v\ {\isacharequal}\ {\isacharparenleft}\ return\ {\isacharparenleft}cons{\isacharunderscore}vec\ b\ v{\isacharparenright}{\isacharparenright}{\isachardoublequoteclose}\isanewline
+\isanewline
+\isacommand{definition}\isamarkupfalse%
+\ cons{\isacharunderscore}vec{\isacharunderscore}nondet\ \ {\isacharcolon}{\isacharcolon}\ {\isachardoublequoteopen}\ bitU\ {\isasymRightarrow}{\isacharparenleft}bitU{\isacharparenright}list\ {\isasymRightarrow}{\isacharparenleft}{\isacharprime}b{\isacharcomma}{\isacharparenleft}{\isacharparenleft}bitU{\isacharparenright}list{\isacharparenright}{\isacharcomma}{\isacharprime}a{\isacharparenright}monad\ {\isachardoublequoteclose}\ \ \isakeyword{where}\ \isanewline
+\ \ \ \ \ {\isachardoublequoteopen}\ cons{\isacharunderscore}vec{\isacharunderscore}nondet\ b\ v\ {\isacharequal}\ {\isacharparenleft}\ return\ {\isacharparenleft}cons{\isacharunderscore}vec\ b\ v{\isacharparenright}{\isacharparenright}{\isachardoublequoteclose}\isanewline
+\isanewline
+\isanewline
+%
+\isamarkupcmt{\isa{val\ cast{\isacharunderscore}unit{\isacharunderscore}vec\ {\isacharcolon}\ bitU\ {\isacharminus}{\isachargreater}\ list\ bitU}%
+}\isanewline
+\isacommand{definition}\isamarkupfalse%
+\ cast{\isacharunderscore}unit{\isacharunderscore}vec\ \ {\isacharcolon}{\isacharcolon}\ {\isachardoublequoteopen}\ bitU\ {\isasymRightarrow}{\isacharparenleft}bitU{\isacharparenright}list\ {\isachardoublequoteclose}\ \ \isakeyword{where}\ \isanewline
+\ \ \ \ \ {\isachardoublequoteopen}\ cast{\isacharunderscore}unit{\isacharunderscore}vec\ {\isacharequal}\ {\isacharparenleft}\ cast{\isacharunderscore}unit{\isacharunderscore}bv\ {\isacharparenright}{\isachardoublequoteclose}\isanewline
+\isanewline
+\isacommand{definition}\isamarkupfalse%
+\ cast{\isacharunderscore}unit{\isacharunderscore}vec{\isacharunderscore}maybe\ \ {\isacharcolon}{\isacharcolon}\ {\isachardoublequoteopen}\ bitU\ {\isasymRightarrow}{\isacharparenleft}{\isacharparenleft}bitU{\isacharparenright}list{\isacharparenright}option\ {\isachardoublequoteclose}\ \ \isakeyword{where}\ \isanewline
+\ \ \ \ \ {\isachardoublequoteopen}\ cast{\isacharunderscore}unit{\isacharunderscore}vec{\isacharunderscore}maybe\ b\ {\isacharequal}\ {\isacharparenleft}\ Some\ {\isacharparenleft}cast{\isacharunderscore}unit{\isacharunderscore}vec\ b{\isacharparenright}{\isacharparenright}{\isachardoublequoteclose}\isanewline
+\isanewline
+\isacommand{definition}\isamarkupfalse%
+\ cast{\isacharunderscore}unit{\isacharunderscore}vec{\isacharunderscore}fail\ \ {\isacharcolon}{\isacharcolon}\ {\isachardoublequoteopen}\ bitU\ {\isasymRightarrow}{\isacharparenleft}{\isacharprime}b{\isacharcomma}{\isacharparenleft}{\isacharparenleft}bitU{\isacharparenright}list{\isacharparenright}{\isacharcomma}{\isacharprime}a{\isacharparenright}monad\ {\isachardoublequoteclose}\ \ \isakeyword{where}\ \isanewline
+\ \ \ \ \ {\isachardoublequoteopen}\ cast{\isacharunderscore}unit{\isacharunderscore}vec{\isacharunderscore}fail\ b\ {\isacharequal}\ {\isacharparenleft}\ return\ {\isacharparenleft}cast{\isacharunderscore}unit{\isacharunderscore}vec\ b{\isacharparenright}{\isacharparenright}{\isachardoublequoteclose}\isanewline
+\isanewline
+\isacommand{definition}\isamarkupfalse%
+\ cast{\isacharunderscore}unit{\isacharunderscore}vec{\isacharunderscore}nondet\ \ {\isacharcolon}{\isacharcolon}\ {\isachardoublequoteopen}\ bitU\ {\isasymRightarrow}{\isacharparenleft}{\isacharprime}b{\isacharcomma}{\isacharparenleft}{\isacharparenleft}bitU{\isacharparenright}list{\isacharparenright}{\isacharcomma}{\isacharprime}a{\isacharparenright}monad\ {\isachardoublequoteclose}\ \ \isakeyword{where}\ \isanewline
+\ \ \ \ \ {\isachardoublequoteopen}\ cast{\isacharunderscore}unit{\isacharunderscore}vec{\isacharunderscore}nondet\ b\ {\isacharequal}\ {\isacharparenleft}\ return\ {\isacharparenleft}cast{\isacharunderscore}unit{\isacharunderscore}vec\ b{\isacharparenright}{\isacharparenright}{\isachardoublequoteclose}\isanewline
+\isanewline
+\isanewline
+%
+\isamarkupcmt{\isa{val\ vec{\isacharunderscore}of{\isacharunderscore}bit\ {\isacharcolon}\ integer\ {\isacharminus}{\isachargreater}\ bitU\ {\isacharminus}{\isachargreater}\ list\ bitU}%
+}\isanewline
+\isacommand{definition}\isamarkupfalse%
+\ vec{\isacharunderscore}of{\isacharunderscore}bit\ \ {\isacharcolon}{\isacharcolon}\ {\isachardoublequoteopen}\ int\ {\isasymRightarrow}\ bitU\ {\isasymRightarrow}{\isacharparenleft}bitU{\isacharparenright}list\ {\isachardoublequoteclose}\ \ \isakeyword{where}\ \isanewline
+\ \ \ \ \ {\isachardoublequoteopen}\ vec{\isacharunderscore}of{\isacharunderscore}bit\ {\isacharequal}\ {\isacharparenleft}\ bv{\isacharunderscore}of{\isacharunderscore}bit\ {\isacharparenright}{\isachardoublequoteclose}\isanewline
+\isanewline
+\isacommand{definition}\isamarkupfalse%
+\ vec{\isacharunderscore}of{\isacharunderscore}bit{\isacharunderscore}maybe\ \ {\isacharcolon}{\isacharcolon}\ {\isachardoublequoteopen}\ int\ {\isasymRightarrow}\ bitU\ {\isasymRightarrow}{\isacharparenleft}{\isacharparenleft}bitU{\isacharparenright}list{\isacharparenright}option\ {\isachardoublequoteclose}\ \ \isakeyword{where}\ \isanewline
+\ \ \ \ \ {\isachardoublequoteopen}\ vec{\isacharunderscore}of{\isacharunderscore}bit{\isacharunderscore}maybe\ len\ b\ {\isacharequal}\ {\isacharparenleft}\ Some\ {\isacharparenleft}vec{\isacharunderscore}of{\isacharunderscore}bit\ len\ b{\isacharparenright}{\isacharparenright}{\isachardoublequoteclose}\isanewline
+\isanewline
+\isacommand{definition}\isamarkupfalse%
+\ vec{\isacharunderscore}of{\isacharunderscore}bit{\isacharunderscore}fail\ \ {\isacharcolon}{\isacharcolon}\ {\isachardoublequoteopen}\ int\ {\isasymRightarrow}\ bitU\ {\isasymRightarrow}{\isacharparenleft}{\isacharprime}b{\isacharcomma}{\isacharparenleft}{\isacharparenleft}bitU{\isacharparenright}list{\isacharparenright}{\isacharcomma}{\isacharprime}a{\isacharparenright}monad\ {\isachardoublequoteclose}\ \ \isakeyword{where}\ \isanewline
+\ \ \ \ \ {\isachardoublequoteopen}\ vec{\isacharunderscore}of{\isacharunderscore}bit{\isacharunderscore}fail\ len\ b\ {\isacharequal}\ {\isacharparenleft}\ return\ {\isacharparenleft}vec{\isacharunderscore}of{\isacharunderscore}bit\ len\ b{\isacharparenright}{\isacharparenright}{\isachardoublequoteclose}\isanewline
+\isanewline
+\isacommand{definition}\isamarkupfalse%
+\ vec{\isacharunderscore}of{\isacharunderscore}bit{\isacharunderscore}nondet\ \ {\isacharcolon}{\isacharcolon}\ {\isachardoublequoteopen}\ int\ {\isasymRightarrow}\ bitU\ {\isasymRightarrow}{\isacharparenleft}{\isacharprime}b{\isacharcomma}{\isacharparenleft}{\isacharparenleft}bitU{\isacharparenright}list{\isacharparenright}{\isacharcomma}{\isacharprime}a{\isacharparenright}monad\ {\isachardoublequoteclose}\ \ \isakeyword{where}\ \isanewline
+\ \ \ \ \ {\isachardoublequoteopen}\ vec{\isacharunderscore}of{\isacharunderscore}bit{\isacharunderscore}nondet\ len\ b\ {\isacharequal}\ {\isacharparenleft}\ return\ {\isacharparenleft}vec{\isacharunderscore}of{\isacharunderscore}bit\ len\ b{\isacharparenright}{\isacharparenright}{\isachardoublequoteclose}\isanewline
+\isanewline
+\isanewline
+%
+\isamarkupcmt{\isa{val\ msb\ {\isacharcolon}\ list\ bitU\ {\isacharminus}{\isachargreater}\ bitU}%
+}\isanewline
+\isacommand{definition}\isamarkupfalse%
+\ msb\ \ {\isacharcolon}{\isacharcolon}\ {\isachardoublequoteopen}{\isacharparenleft}bitU{\isacharparenright}list\ {\isasymRightarrow}\ bitU\ {\isachardoublequoteclose}\ \ \isakeyword{where}\ \isanewline
+\ \ \ \ \ {\isachardoublequoteopen}\ msb\ {\isacharequal}\ {\isacharparenleft}\ \isanewline
+\ \ most{\isacharunderscore}significant\isanewline
+\ \ \ \ {\isacharparenleft}instance{\isacharunderscore}Sail{\isadigit{2}}{\isacharunderscore}values{\isacharunderscore}Bitvector{\isacharunderscore}list{\isacharunderscore}dict\isanewline
+\ \ \ \ \ \ \ instance{\isacharunderscore}Sail{\isadigit{2}}{\isacharunderscore}values{\isacharunderscore}BitU{\isacharunderscore}Sail{\isadigit{2}}{\isacharunderscore}values{\isacharunderscore}bitU{\isacharunderscore}dict{\isacharparenright}\ {\isacharparenright}{\isachardoublequoteclose}\isanewline
+\isanewline
+\isanewline
+%
+\isamarkupcmt{\isa{val\ int{\isacharunderscore}of{\isacharunderscore}vec{\isacharunderscore}maybe\ {\isacharcolon}\ bool\ {\isacharminus}{\isachargreater}\ list\ bitU\ {\isacharminus}{\isachargreater}\ maybe\ integer}%
+}\isanewline
+\isacommand{definition}\isamarkupfalse%
+\ int{\isacharunderscore}of{\isacharunderscore}vec{\isacharunderscore}maybe\ \ {\isacharcolon}{\isacharcolon}\ {\isachardoublequoteopen}\ bool\ {\isasymRightarrow}{\isacharparenleft}bitU{\isacharparenright}list\ {\isasymRightarrow}{\isacharparenleft}int{\isacharparenright}option\ {\isachardoublequoteclose}\ \ \isakeyword{where}\ \isanewline
+\ \ \ \ \ {\isachardoublequoteopen}\ int{\isacharunderscore}of{\isacharunderscore}vec{\isacharunderscore}maybe\ {\isacharequal}\ {\isacharparenleft}\ \isanewline
+\ \ int{\isacharunderscore}of{\isacharunderscore}bv\isanewline
+\ \ \ \ {\isacharparenleft}instance{\isacharunderscore}Sail{\isadigit{2}}{\isacharunderscore}values{\isacharunderscore}Bitvector{\isacharunderscore}list{\isacharunderscore}dict\isanewline
+\ \ \ \ \ \ \ instance{\isacharunderscore}Sail{\isadigit{2}}{\isacharunderscore}values{\isacharunderscore}BitU{\isacharunderscore}Sail{\isadigit{2}}{\isacharunderscore}values{\isacharunderscore}bitU{\isacharunderscore}dict{\isacharparenright}\ {\isacharparenright}{\isachardoublequoteclose}\isanewline
+\isanewline
+\isacommand{definition}\isamarkupfalse%
+\ int{\isacharunderscore}of{\isacharunderscore}vec{\isacharunderscore}fail\ \ {\isacharcolon}{\isacharcolon}\ {\isachardoublequoteopen}\ bool\ {\isasymRightarrow}{\isacharparenleft}bitU{\isacharparenright}list\ {\isasymRightarrow}{\isacharparenleft}{\isacharprime}b{\isacharcomma}{\isacharparenleft}int{\isacharparenright}{\isacharcomma}{\isacharprime}a{\isacharparenright}monad\ {\isachardoublequoteclose}\ \ \isakeyword{where}\ \isanewline
+\ \ \ \ \ {\isachardoublequoteopen}\ int{\isacharunderscore}of{\isacharunderscore}vec{\isacharunderscore}fail\ sign\ v\ {\isacharequal}\ {\isacharparenleft}\ maybe{\isacharunderscore}fail\ {\isacharparenleft}{\isacharprime}{\isacharprime}int{\isacharunderscore}of{\isacharunderscore}vec{\isacharprime}{\isacharprime}{\isacharparenright}\ {\isacharparenleft}int{\isacharunderscore}of{\isacharunderscore}vec{\isacharunderscore}maybe\ sign\ v{\isacharparenright}{\isacharparenright}{\isachardoublequoteclose}\isanewline
+\isanewline
+\isacommand{definition}\isamarkupfalse%
+\ int{\isacharunderscore}of{\isacharunderscore}vec{\isacharunderscore}nondet\ \ {\isacharcolon}{\isacharcolon}\ {\isachardoublequoteopen}\ bool\ {\isasymRightarrow}{\isacharparenleft}bitU{\isacharparenright}list\ {\isasymRightarrow}{\isacharparenleft}{\isacharprime}b{\isacharcomma}{\isacharparenleft}int{\isacharparenright}{\isacharcomma}{\isacharprime}a{\isacharparenright}monad\ {\isachardoublequoteclose}\ \ \isakeyword{where}\ \isanewline
+\ \ \ \ \ {\isachardoublequoteopen}\ int{\isacharunderscore}of{\isacharunderscore}vec{\isacharunderscore}nondet\ sign\ v\ {\isacharequal}\ {\isacharparenleft}\ bools{\isacharunderscore}of{\isacharunderscore}bits{\isacharunderscore}nondet\ v\ {\isasymbind}\ {\isacharparenleft}{\isasymlambda}\ v\ {\isachardot}\ \ return\ {\isacharparenleft}int{\isacharunderscore}of{\isacharunderscore}bools\ sign\ v{\isacharparenright}{\isacharparenright}{\isacharparenright}{\isachardoublequoteclose}\isanewline
+\isanewline
+\isacommand{definition}\isamarkupfalse%
+\ int{\isacharunderscore}of{\isacharunderscore}vec\ \ {\isacharcolon}{\isacharcolon}\ {\isachardoublequoteopen}\ bool\ {\isasymRightarrow}{\isacharparenleft}bitU{\isacharparenright}list\ {\isasymRightarrow}\ int\ {\isachardoublequoteclose}\ \ \isakeyword{where}\ \isanewline
+\ \ \ \ \ {\isachardoublequoteopen}\ int{\isacharunderscore}of{\isacharunderscore}vec\ sign\ v\ {\isacharequal}\ {\isacharparenleft}\ maybe{\isacharunderscore}failwith\ {\isacharparenleft}int{\isacharunderscore}of{\isacharunderscore}vec{\isacharunderscore}maybe\ sign\ v{\isacharparenright}{\isacharparenright}{\isachardoublequoteclose}\isanewline
+\isanewline
+\isanewline
+%
+\isamarkupcmt{\isa{val\ string{\isacharunderscore}of{\isacharunderscore}bits\ {\isacharcolon}\ list\ bitU\ {\isacharminus}{\isachargreater}\ string}%
+}\isanewline
+\isacommand{definition}\isamarkupfalse%
+\ string{\isacharunderscore}of{\isacharunderscore}bits\ \ {\isacharcolon}{\isacharcolon}\ {\isachardoublequoteopen}{\isacharparenleft}bitU{\isacharparenright}list\ {\isasymRightarrow}\ string\ {\isachardoublequoteclose}\ \ \isakeyword{where}\ \isanewline
+\ \ \ \ \ {\isachardoublequoteopen}\ string{\isacharunderscore}of{\isacharunderscore}bits\ {\isacharequal}\ {\isacharparenleft}\ \isanewline
+\ \ string{\isacharunderscore}of{\isacharunderscore}bv\isanewline
+\ \ \ \ {\isacharparenleft}instance{\isacharunderscore}Sail{\isadigit{2}}{\isacharunderscore}values{\isacharunderscore}Bitvector{\isacharunderscore}list{\isacharunderscore}dict\isanewline
+\ \ \ \ \ \ \ instance{\isacharunderscore}Sail{\isadigit{2}}{\isacharunderscore}values{\isacharunderscore}BitU{\isacharunderscore}Sail{\isadigit{2}}{\isacharunderscore}values{\isacharunderscore}bitU{\isacharunderscore}dict{\isacharparenright}\ {\isacharparenright}{\isachardoublequoteclose}\isanewline
+\isanewline
+\isanewline
+%
+\isamarkupcmt{\isa{val\ decimal{\isacharunderscore}string{\isacharunderscore}of{\isacharunderscore}bits\ {\isacharcolon}\ list\ bitU\ {\isacharminus}{\isachargreater}\ string}%
+}\isanewline
+\isacommand{definition}\isamarkupfalse%
+\ decimal{\isacharunderscore}string{\isacharunderscore}of{\isacharunderscore}bits\ \ {\isacharcolon}{\isacharcolon}\ {\isachardoublequoteopen}{\isacharparenleft}bitU{\isacharparenright}list\ {\isasymRightarrow}\ string\ {\isachardoublequoteclose}\ \ \isakeyword{where}\ \isanewline
+\ \ \ \ \ {\isachardoublequoteopen}\ decimal{\isacharunderscore}string{\isacharunderscore}of{\isacharunderscore}bits\ {\isacharequal}\ {\isacharparenleft}\ \isanewline
+\ \ decimal{\isacharunderscore}string{\isacharunderscore}of{\isacharunderscore}bv\isanewline
+\ \ \ \ {\isacharparenleft}instance{\isacharunderscore}Sail{\isadigit{2}}{\isacharunderscore}values{\isacharunderscore}Bitvector{\isacharunderscore}list{\isacharunderscore}dict\isanewline
+\ \ \ \ \ \ \ instance{\isacharunderscore}Sail{\isadigit{2}}{\isacharunderscore}values{\isacharunderscore}BitU{\isacharunderscore}Sail{\isadigit{2}}{\isacharunderscore}values{\isacharunderscore}bitU{\isacharunderscore}dict{\isacharparenright}\ {\isacharparenright}{\isachardoublequoteclose}\isanewline
+\isanewline
+\isanewline
+%
+\isamarkupcmt{\isa{val\ and{\isacharunderscore}vec\ {\isacharcolon}\ list\ bitU\ {\isacharminus}{\isachargreater}\ list\ bitU\ {\isacharminus}{\isachargreater}\ list\ bitU}%
+}\isanewline
+%
+\isamarkupcmt{\isa{val\ or{\isacharunderscore}vec\ \ {\isacharcolon}\ list\ bitU\ {\isacharminus}{\isachargreater}\ list\ bitU\ {\isacharminus}{\isachargreater}\ list\ bitU}%
+}\isanewline
+%
+\isamarkupcmt{\isa{val\ xor{\isacharunderscore}vec\ {\isacharcolon}\ list\ bitU\ {\isacharminus}{\isachargreater}\ list\ bitU\ {\isacharminus}{\isachargreater}\ list\ bitU}%
+}\isanewline
+%
+\isamarkupcmt{\isa{val\ not{\isacharunderscore}vec\ {\isacharcolon}\ list\ bitU\ {\isacharminus}{\isachargreater}\ list\ bitU}%
+}\isanewline
+\isacommand{definition}\isamarkupfalse%
+\ and{\isacharunderscore}vec\ \ {\isacharcolon}{\isacharcolon}\ {\isachardoublequoteopen}{\isacharparenleft}bitU{\isacharparenright}list\ {\isasymRightarrow}{\isacharparenleft}bitU{\isacharparenright}list\ {\isasymRightarrow}{\isacharparenleft}bitU{\isacharparenright}list\ {\isachardoublequoteclose}\ \ \isakeyword{where}\ \isanewline
+\ \ \ \ \ {\isachardoublequoteopen}\ and{\isacharunderscore}vec\ {\isacharequal}\ {\isacharparenleft}\ binop{\isacharunderscore}list\ and{\isacharunderscore}bit\ {\isacharparenright}{\isachardoublequoteclose}\isanewline
+\isanewline
+\isacommand{definition}\isamarkupfalse%
+\ or{\isacharunderscore}vec\ \ {\isacharcolon}{\isacharcolon}\ {\isachardoublequoteopen}{\isacharparenleft}bitU{\isacharparenright}list\ {\isasymRightarrow}{\isacharparenleft}bitU{\isacharparenright}list\ {\isasymRightarrow}{\isacharparenleft}bitU{\isacharparenright}list\ {\isachardoublequoteclose}\ \ \ \isakeyword{where}\ \isanewline
+\ \ \ \ \ {\isachardoublequoteopen}\ or{\isacharunderscore}vec\ \ {\isacharequal}\ {\isacharparenleft}\ binop{\isacharunderscore}list\ or{\isacharunderscore}bit\ {\isacharparenright}{\isachardoublequoteclose}\isanewline
+\isanewline
+\isacommand{definition}\isamarkupfalse%
+\ xor{\isacharunderscore}vec\ \ {\isacharcolon}{\isacharcolon}\ {\isachardoublequoteopen}{\isacharparenleft}bitU{\isacharparenright}list\ {\isasymRightarrow}{\isacharparenleft}bitU{\isacharparenright}list\ {\isasymRightarrow}{\isacharparenleft}bitU{\isacharparenright}list\ {\isachardoublequoteclose}\ \ \isakeyword{where}\ \isanewline
+\ \ \ \ \ {\isachardoublequoteopen}\ xor{\isacharunderscore}vec\ {\isacharequal}\ {\isacharparenleft}\ binop{\isacharunderscore}list\ xor{\isacharunderscore}bit\ {\isacharparenright}{\isachardoublequoteclose}\isanewline
+\isanewline
+\isacommand{definition}\isamarkupfalse%
+\ not{\isacharunderscore}vec\ \ {\isacharcolon}{\isacharcolon}\ {\isachardoublequoteopen}{\isacharparenleft}bitU{\isacharparenright}list\ {\isasymRightarrow}{\isacharparenleft}bitU{\isacharparenright}list\ {\isachardoublequoteclose}\ \ \isakeyword{where}\ \isanewline
+\ \ \ \ \ {\isachardoublequoteopen}\ not{\isacharunderscore}vec\ {\isacharequal}\ {\isacharparenleft}\ List{\isachardot}map\ not{\isacharunderscore}bit\ {\isacharparenright}{\isachardoublequoteclose}\isanewline
+\isanewline
+\isanewline
+%
+\isamarkupcmt{\isa{val\ arith{\isacharunderscore}op{\isacharunderscore}double{\isacharunderscore}bl\ {\isacharcolon}\ forall\ {\isacharprime}a\ {\isacharprime}b{\isachardot}\ Bitvector\ {\isacharprime}a\ {\isacharequal}{\isachargreater}\ {\isacharparenleft}integer\ {\isacharminus}{\isachargreater}\ integer\ {\isacharminus}{\isachargreater}\ integer{\isacharparenright}\ {\isacharminus}{\isachargreater}\ bool\ {\isacharminus}{\isachargreater}\ {\isacharprime}a\ {\isacharminus}{\isachargreater}\ {\isacharprime}a\ {\isacharminus}{\isachargreater}\ list\ bitU}%
+}\isanewline
+\isacommand{definition}\isamarkupfalse%
+\ arith{\isacharunderscore}op{\isacharunderscore}double{\isacharunderscore}bl\ \ {\isacharcolon}{\isacharcolon}\ {\isachardoublequoteopen}\ {\isacharprime}a\ Bitvector{\isacharunderscore}class\ {\isasymRightarrow}{\isacharparenleft}int\ {\isasymRightarrow}\ int\ {\isasymRightarrow}\ int{\isacharparenright}{\isasymRightarrow}\ bool\ {\isasymRightarrow}\ {\isacharprime}a\ {\isasymRightarrow}\ {\isacharprime}a\ {\isasymRightarrow}{\isacharparenleft}bitU{\isacharparenright}list\ {\isachardoublequoteclose}\ \ \isakeyword{where}\ \isanewline
+\ \ \ \ \ {\isachardoublequoteopen}\ arith{\isacharunderscore}op{\isacharunderscore}double{\isacharunderscore}bl\ dict{\isacharunderscore}Sail{\isadigit{2}}{\isacharunderscore}values{\isacharunderscore}Bitvector{\isacharunderscore}a\ op{\isadigit{1}}\ sign\ l\ r\ {\isacharequal}\ {\isacharparenleft}\isanewline
+\ \ {\isacharparenleft}let\ len\ {\isacharequal}{\isacharparenleft}{\isacharparenleft}\ {\isadigit{2}}\ {\isacharcolon}{\isacharcolon}\ int{\isacharparenright}\ {\isacharasterisk}\isanewline
+\ \ {\isacharparenleft}length{\isacharunderscore}method\ \ \ dict{\isacharunderscore}Sail{\isadigit{2}}{\isacharunderscore}values{\isacharunderscore}Bitvector{\isacharunderscore}a{\isacharparenright}\ l{\isacharparenright}\ in\isanewline
+\ \ {\isacharparenleft}let\ l{\isacharprime}\ {\isacharequal}\ {\isacharparenleft}if\ sign\ then\ exts{\isacharunderscore}bv\ \isanewline
+\ \ dict{\isacharunderscore}Sail{\isadigit{2}}{\isacharunderscore}values{\isacharunderscore}Bitvector{\isacharunderscore}a\ len\ l\ else\ extz{\isacharunderscore}bv\ dict{\isacharunderscore}Sail{\isadigit{2}}{\isacharunderscore}values{\isacharunderscore}Bitvector{\isacharunderscore}a\ len\ l{\isacharparenright}\ in\isanewline
+\ \ {\isacharparenleft}let\ r{\isacharprime}\ {\isacharequal}\ {\isacharparenleft}if\ sign\ then\ exts{\isacharunderscore}bv\ \isanewline
+\ \ dict{\isacharunderscore}Sail{\isadigit{2}}{\isacharunderscore}values{\isacharunderscore}Bitvector{\isacharunderscore}a\ len\ r\ else\ extz{\isacharunderscore}bv\ dict{\isacharunderscore}Sail{\isadigit{2}}{\isacharunderscore}values{\isacharunderscore}Bitvector{\isacharunderscore}a\ len\ r{\isacharparenright}\ in\isanewline
+\ \ List{\isachardot}map\ {\isacharparenleft}{\isasymlambda}\ b{\isachardot}\ b{\isacharparenright}\ {\isacharparenleft}arith{\isacharunderscore}op{\isacharunderscore}bits\ op{\isadigit{1}}\ sign\ {\isacharparenleft}List{\isachardot}map\ {\isacharparenleft}{\isasymlambda}\ b{\isachardot}\ b{\isacharparenright}\ l{\isacharprime}{\isacharparenright}\ {\isacharparenleft}List{\isachardot}map\ {\isacharparenleft}{\isasymlambda}\ b{\isachardot}\ b{\isacharparenright}\ r{\isacharprime}{\isacharparenright}{\isacharparenright}{\isacharparenright}{\isacharparenright}{\isacharparenright}{\isacharparenright}{\isachardoublequoteclose}\isanewline
+\isanewline
+\isanewline
+%
+\isamarkupcmt{\isa{val\ add{\isacharunderscore}vec\ \ \ {\isacharcolon}\ list\ bitU\ {\isacharminus}{\isachargreater}\ list\ bitU\ {\isacharminus}{\isachargreater}\ list\ bitU}%
+}\isanewline
+%
+\isamarkupcmt{\isa{val\ adds{\isacharunderscore}vec\ \ {\isacharcolon}\ list\ bitU\ {\isacharminus}{\isachargreater}\ list\ bitU\ {\isacharminus}{\isachargreater}\ list\ bitU}%
+}\isanewline
+%
+\isamarkupcmt{\isa{val\ sub{\isacharunderscore}vec\ \ \ {\isacharcolon}\ list\ bitU\ {\isacharminus}{\isachargreater}\ list\ bitU\ {\isacharminus}{\isachargreater}\ list\ bitU}%
+}\isanewline
+%
+\isamarkupcmt{\isa{val\ subs{\isacharunderscore}vec\ \ {\isacharcolon}\ list\ bitU\ {\isacharminus}{\isachargreater}\ list\ bitU\ {\isacharminus}{\isachargreater}\ list\ bitU}%
+}\isanewline
+%
+\isamarkupcmt{\isa{val\ mult{\isacharunderscore}vec\ \ {\isacharcolon}\ list\ bitU\ {\isacharminus}{\isachargreater}\ list\ bitU\ {\isacharminus}{\isachargreater}\ list\ bitU}%
+}\isanewline
+%
+\isamarkupcmt{\isa{val\ mults{\isacharunderscore}vec\ {\isacharcolon}\ list\ bitU\ {\isacharminus}{\isachargreater}\ list\ bitU\ {\isacharminus}{\isachargreater}\ list\ bitU}%
+}\isanewline
+\isacommand{definition}\isamarkupfalse%
+\ add{\isacharunderscore}vec\ \ {\isacharcolon}{\isacharcolon}\ {\isachardoublequoteopen}{\isacharparenleft}bitU{\isacharparenright}list\ {\isasymRightarrow}{\isacharparenleft}bitU{\isacharparenright}list\ {\isasymRightarrow}{\isacharparenleft}bitU{\isacharparenright}list\ {\isachardoublequoteclose}\ \ \ \ \isakeyword{where}\ \isanewline
+\ \ \ \ \ {\isachardoublequoteopen}\ add{\isacharunderscore}vec\ \ \ {\isacharequal}\ {\isacharparenleft}\ {\isacharparenleft}{\isasymlambda}\ l\ r{\isachardot}\ List{\isachardot}map\ {\isacharparenleft}{\isasymlambda}\ b{\isachardot}\ b{\isacharparenright}\ {\isacharparenleft}arith{\isacharunderscore}op{\isacharunderscore}bits\ {\isacharparenleft}{\isacharplus}{\isacharparenright}\ False\ {\isacharparenleft}List{\isachardot}map\ {\isacharparenleft}{\isasymlambda}\ b{\isachardot}\ b{\isacharparenright}\ l{\isacharparenright}\ {\isacharparenleft}List{\isachardot}map\ {\isacharparenleft}{\isasymlambda}\ b{\isachardot}\ b{\isacharparenright}\ r{\isacharparenright}{\isacharparenright}{\isacharparenright}{\isacharparenright}{\isachardoublequoteclose}\isanewline
+\isanewline
+\isacommand{definition}\isamarkupfalse%
+\ adds{\isacharunderscore}vec\ \ {\isacharcolon}{\isacharcolon}\ {\isachardoublequoteopen}{\isacharparenleft}bitU{\isacharparenright}list\ {\isasymRightarrow}{\isacharparenleft}bitU{\isacharparenright}list\ {\isasymRightarrow}{\isacharparenleft}bitU{\isacharparenright}list\ {\isachardoublequoteclose}\ \ \ \isakeyword{where}\ \isanewline
+\ \ \ \ \ {\isachardoublequoteopen}\ adds{\isacharunderscore}vec\ \ {\isacharequal}\ {\isacharparenleft}\ {\isacharparenleft}{\isasymlambda}\ l\ r{\isachardot}\ List{\isachardot}map\ {\isacharparenleft}{\isasymlambda}\ b{\isachardot}\ b{\isacharparenright}\ {\isacharparenleft}arith{\isacharunderscore}op{\isacharunderscore}bits\ {\isacharparenleft}{\isacharplus}{\isacharparenright}\ True\ {\isacharparenleft}List{\isachardot}map\ {\isacharparenleft}{\isasymlambda}\ b{\isachardot}\ b{\isacharparenright}\ l{\isacharparenright}\ {\isacharparenleft}List{\isachardot}map\ {\isacharparenleft}{\isasymlambda}\ b{\isachardot}\ b{\isacharparenright}\ r{\isacharparenright}{\isacharparenright}{\isacharparenright}{\isacharparenright}{\isachardoublequoteclose}\isanewline
+\isanewline
+\isacommand{definition}\isamarkupfalse%
+\ sub{\isacharunderscore}vec\ \ {\isacharcolon}{\isacharcolon}\ {\isachardoublequoteopen}{\isacharparenleft}bitU{\isacharparenright}list\ {\isasymRightarrow}{\isacharparenleft}bitU{\isacharparenright}list\ {\isasymRightarrow}{\isacharparenleft}bitU{\isacharparenright}list\ {\isachardoublequoteclose}\ \ \ \ \isakeyword{where}\ \isanewline
+\ \ \ \ \ {\isachardoublequoteopen}\ sub{\isacharunderscore}vec\ \ \ {\isacharequal}\ {\isacharparenleft}\ {\isacharparenleft}{\isasymlambda}\ l\ r{\isachardot}\ List{\isachardot}map\ {\isacharparenleft}{\isasymlambda}\ b{\isachardot}\ b{\isacharparenright}\ {\isacharparenleft}arith{\isacharunderscore}op{\isacharunderscore}bits\ {\isacharparenleft}{\isacharminus}{\isacharparenright}\ False\ {\isacharparenleft}List{\isachardot}map\ {\isacharparenleft}{\isasymlambda}\ b{\isachardot}\ b{\isacharparenright}\ l{\isacharparenright}\ {\isacharparenleft}List{\isachardot}map\ {\isacharparenleft}{\isasymlambda}\ b{\isachardot}\ b{\isacharparenright}\ r{\isacharparenright}{\isacharparenright}{\isacharparenright}{\isacharparenright}{\isachardoublequoteclose}\isanewline
+\isanewline
+\isacommand{definition}\isamarkupfalse%
+\ subs{\isacharunderscore}vec\ \ {\isacharcolon}{\isacharcolon}\ {\isachardoublequoteopen}{\isacharparenleft}bitU{\isacharparenright}list\ {\isasymRightarrow}{\isacharparenleft}bitU{\isacharparenright}list\ {\isasymRightarrow}{\isacharparenleft}bitU{\isacharparenright}list\ {\isachardoublequoteclose}\ \ \ \isakeyword{where}\ \isanewline
+\ \ \ \ \ {\isachardoublequoteopen}\ subs{\isacharunderscore}vec\ \ {\isacharequal}\ {\isacharparenleft}\ {\isacharparenleft}{\isasymlambda}\ l\ r{\isachardot}\ List{\isachardot}map\ {\isacharparenleft}{\isasymlambda}\ b{\isachardot}\ b{\isacharparenright}\ {\isacharparenleft}arith{\isacharunderscore}op{\isacharunderscore}bits\ {\isacharparenleft}{\isacharminus}{\isacharparenright}\ True\ {\isacharparenleft}List{\isachardot}map\ {\isacharparenleft}{\isasymlambda}\ b{\isachardot}\ b{\isacharparenright}\ l{\isacharparenright}\ {\isacharparenleft}List{\isachardot}map\ {\isacharparenleft}{\isasymlambda}\ b{\isachardot}\ b{\isacharparenright}\ r{\isacharparenright}{\isacharparenright}{\isacharparenright}{\isacharparenright}{\isachardoublequoteclose}\isanewline
+\isanewline
+\isacommand{definition}\isamarkupfalse%
+\ mult{\isacharunderscore}vec\ \ {\isacharcolon}{\isacharcolon}\ {\isachardoublequoteopen}{\isacharparenleft}bitU{\isacharparenright}list\ {\isasymRightarrow}{\isacharparenleft}bitU{\isacharparenright}list\ {\isasymRightarrow}{\isacharparenleft}bitU{\isacharparenright}list\ {\isachardoublequoteclose}\ \ \ \isakeyword{where}\ \isanewline
+\ \ \ \ \ {\isachardoublequoteopen}\ mult{\isacharunderscore}vec\ \ {\isacharequal}\ {\isacharparenleft}\ arith{\isacharunderscore}op{\isacharunderscore}double{\isacharunderscore}bl\ \isanewline
+\ \ {\isacharparenleft}instance{\isacharunderscore}Sail{\isadigit{2}}{\isacharunderscore}values{\isacharunderscore}Bitvector{\isacharunderscore}list{\isacharunderscore}dict\isanewline
+\ \ \ \ \ instance{\isacharunderscore}Sail{\isadigit{2}}{\isacharunderscore}values{\isacharunderscore}BitU{\isacharunderscore}Sail{\isadigit{2}}{\isacharunderscore}values{\isacharunderscore}bitU{\isacharunderscore}dict{\isacharparenright}\ {\isacharparenleft}\ {\isacharasterisk}\ {\isacharparenright}\ False\ {\isacharparenright}{\isachardoublequoteclose}\isanewline
+\isanewline
+\isacommand{definition}\isamarkupfalse%
+\ mults{\isacharunderscore}vec\ \ {\isacharcolon}{\isacharcolon}\ {\isachardoublequoteopen}{\isacharparenleft}bitU{\isacharparenright}list\ {\isasymRightarrow}{\isacharparenleft}bitU{\isacharparenright}list\ {\isasymRightarrow}{\isacharparenleft}bitU{\isacharparenright}list\ {\isachardoublequoteclose}\ \ \isakeyword{where}\ \isanewline
+\ \ \ \ \ {\isachardoublequoteopen}\ mults{\isacharunderscore}vec\ {\isacharequal}\ {\isacharparenleft}\ arith{\isacharunderscore}op{\isacharunderscore}double{\isacharunderscore}bl\ \isanewline
+\ \ {\isacharparenleft}instance{\isacharunderscore}Sail{\isadigit{2}}{\isacharunderscore}values{\isacharunderscore}Bitvector{\isacharunderscore}list{\isacharunderscore}dict\isanewline
+\ \ \ \ \ instance{\isacharunderscore}Sail{\isadigit{2}}{\isacharunderscore}values{\isacharunderscore}BitU{\isacharunderscore}Sail{\isadigit{2}}{\isacharunderscore}values{\isacharunderscore}bitU{\isacharunderscore}dict{\isacharparenright}\ {\isacharparenleft}\ {\isacharasterisk}\ {\isacharparenright}\ True\ {\isacharparenright}{\isachardoublequoteclose}\isanewline
+\isanewline
+\isanewline
+%
+\isamarkupcmt{\isa{val\ add{\isacharunderscore}vec{\isacharunderscore}int\ \ \ \ \ \ \ {\isacharcolon}\ list\ bitU\ {\isacharminus}{\isachargreater}\ integer\ {\isacharminus}{\isachargreater}\ list\ bitU}%
+}\isanewline
+%
+\isamarkupcmt{\isa{val\ sub{\isacharunderscore}vec{\isacharunderscore}int\ \ \ \ \ \ \ {\isacharcolon}\ list\ bitU\ {\isacharminus}{\isachargreater}\ integer\ {\isacharminus}{\isachargreater}\ list\ bitU}%
+}\isanewline
+%
+\isamarkupcmt{\isa{val\ mult{\isacharunderscore}vec{\isacharunderscore}int\ \ \ \ \ \ {\isacharcolon}\ list\ bitU\ {\isacharminus}{\isachargreater}\ integer\ {\isacharminus}{\isachargreater}\ list\ bitU}%
+}\isanewline
+\isacommand{definition}\isamarkupfalse%
+\ add{\isacharunderscore}vec{\isacharunderscore}int\ \ {\isacharcolon}{\isacharcolon}\ {\isachardoublequoteopen}{\isacharparenleft}bitU{\isacharparenright}list\ {\isasymRightarrow}\ int\ {\isasymRightarrow}{\isacharparenleft}bitU{\isacharparenright}list\ {\isachardoublequoteclose}\ \ \isakeyword{where}\ \isanewline
+\ \ \ \ \ {\isachardoublequoteopen}\ add{\isacharunderscore}vec{\isacharunderscore}int\ \ \ l\ r\ {\isacharequal}\ {\isacharparenleft}\ arith{\isacharunderscore}op{\isacharunderscore}bv{\isacharunderscore}int\ \isanewline
+\ \ {\isacharparenleft}instance{\isacharunderscore}Sail{\isadigit{2}}{\isacharunderscore}values{\isacharunderscore}Bitvector{\isacharunderscore}list{\isacharunderscore}dict\isanewline
+\ \ \ \ \ instance{\isacharunderscore}Sail{\isadigit{2}}{\isacharunderscore}values{\isacharunderscore}BitU{\isacharunderscore}Sail{\isadigit{2}}{\isacharunderscore}values{\isacharunderscore}bitU{\isacharunderscore}dict{\isacharparenright}\ {\isacharparenleft}{\isacharplus}{\isacharparenright}\ False\ l\ r\ {\isacharparenright}{\isachardoublequoteclose}\isanewline
+\isanewline
+\isacommand{definition}\isamarkupfalse%
+\ sub{\isacharunderscore}vec{\isacharunderscore}int\ \ {\isacharcolon}{\isacharcolon}\ {\isachardoublequoteopen}{\isacharparenleft}bitU{\isacharparenright}list\ {\isasymRightarrow}\ int\ {\isasymRightarrow}{\isacharparenleft}bitU{\isacharparenright}list\ {\isachardoublequoteclose}\ \ \isakeyword{where}\ \isanewline
+\ \ \ \ \ {\isachardoublequoteopen}\ sub{\isacharunderscore}vec{\isacharunderscore}int\ \ \ l\ r\ {\isacharequal}\ {\isacharparenleft}\ arith{\isacharunderscore}op{\isacharunderscore}bv{\isacharunderscore}int\ \isanewline
+\ \ {\isacharparenleft}instance{\isacharunderscore}Sail{\isadigit{2}}{\isacharunderscore}values{\isacharunderscore}Bitvector{\isacharunderscore}list{\isacharunderscore}dict\isanewline
+\ \ \ \ \ instance{\isacharunderscore}Sail{\isadigit{2}}{\isacharunderscore}values{\isacharunderscore}BitU{\isacharunderscore}Sail{\isadigit{2}}{\isacharunderscore}values{\isacharunderscore}bitU{\isacharunderscore}dict{\isacharparenright}\ {\isacharparenleft}{\isacharminus}{\isacharparenright}\ False\ l\ r\ {\isacharparenright}{\isachardoublequoteclose}\isanewline
+\isanewline
+\isacommand{definition}\isamarkupfalse%
+\ mult{\isacharunderscore}vec{\isacharunderscore}int\ \ {\isacharcolon}{\isacharcolon}\ {\isachardoublequoteopen}{\isacharparenleft}bitU{\isacharparenright}list\ {\isasymRightarrow}\ int\ {\isasymRightarrow}{\isacharparenleft}bitU{\isacharparenright}list\ {\isachardoublequoteclose}\ \ \isakeyword{where}\ \isanewline
+\ \ \ \ \ {\isachardoublequoteopen}\ mult{\isacharunderscore}vec{\isacharunderscore}int\ \ l\ r\ {\isacharequal}\ {\isacharparenleft}\ arith{\isacharunderscore}op{\isacharunderscore}double{\isacharunderscore}bl\ \isanewline
+\ \ {\isacharparenleft}instance{\isacharunderscore}Sail{\isadigit{2}}{\isacharunderscore}values{\isacharunderscore}Bitvector{\isacharunderscore}list{\isacharunderscore}dict\isanewline
+\ \ \ \ \ instance{\isacharunderscore}Sail{\isadigit{2}}{\isacharunderscore}values{\isacharunderscore}BitU{\isacharunderscore}Sail{\isadigit{2}}{\isacharunderscore}values{\isacharunderscore}bitU{\isacharunderscore}dict{\isacharparenright}\ {\isacharparenleft}\ {\isacharasterisk}\ {\isacharparenright}\ False\ l\ {\isacharparenleft}List{\isachardot}map\ {\isacharparenleft}{\isasymlambda}\ b{\isachardot}\ b{\isacharparenright}\ {\isacharparenleft}bits{\isacharunderscore}of{\isacharunderscore}int\ {\isacharparenleft}int\ {\isacharparenleft}List{\isachardot}length\ l{\isacharparenright}{\isacharparenright}\ r{\isacharparenright}{\isacharparenright}{\isacharparenright}{\isachardoublequoteclose}\isanewline
+\isanewline
+\isanewline
+%
+\isamarkupcmt{\isa{val\ add{\isacharunderscore}int{\isacharunderscore}vec\ \ \ \ \ \ \ {\isacharcolon}\ integer\ {\isacharminus}{\isachargreater}\ list\ bitU\ {\isacharminus}{\isachargreater}\ list\ bitU}%
+}\isanewline
+%
+\isamarkupcmt{\isa{val\ sub{\isacharunderscore}int{\isacharunderscore}vec\ \ \ \ \ \ \ {\isacharcolon}\ integer\ {\isacharminus}{\isachargreater}\ list\ bitU\ {\isacharminus}{\isachargreater}\ list\ bitU}%
+}\isanewline
+%
+\isamarkupcmt{\isa{val\ mult{\isacharunderscore}int{\isacharunderscore}vec\ \ \ \ \ \ {\isacharcolon}\ integer\ {\isacharminus}{\isachargreater}\ list\ bitU\ {\isacharminus}{\isachargreater}\ list\ bitU}%
+}\isanewline
+\isacommand{definition}\isamarkupfalse%
+\ add{\isacharunderscore}int{\isacharunderscore}vec\ \ {\isacharcolon}{\isacharcolon}\ {\isachardoublequoteopen}\ int\ {\isasymRightarrow}{\isacharparenleft}bitU{\isacharparenright}list\ {\isasymRightarrow}{\isacharparenleft}bitU{\isacharparenright}list\ {\isachardoublequoteclose}\ \ \isakeyword{where}\ \isanewline
+\ \ \ \ \ {\isachardoublequoteopen}\ add{\isacharunderscore}int{\isacharunderscore}vec\ \ \ l\ r\ {\isacharequal}\ {\isacharparenleft}\ arith{\isacharunderscore}op{\isacharunderscore}int{\isacharunderscore}bv\ \isanewline
+\ \ {\isacharparenleft}instance{\isacharunderscore}Sail{\isadigit{2}}{\isacharunderscore}values{\isacharunderscore}Bitvector{\isacharunderscore}list{\isacharunderscore}dict\isanewline
+\ \ \ \ \ instance{\isacharunderscore}Sail{\isadigit{2}}{\isacharunderscore}values{\isacharunderscore}BitU{\isacharunderscore}Sail{\isadigit{2}}{\isacharunderscore}values{\isacharunderscore}bitU{\isacharunderscore}dict{\isacharparenright}\ {\isacharparenleft}{\isacharplus}{\isacharparenright}\ False\ l\ r\ {\isacharparenright}{\isachardoublequoteclose}\isanewline
+\isanewline
+\isacommand{definition}\isamarkupfalse%
+\ sub{\isacharunderscore}int{\isacharunderscore}vec\ \ {\isacharcolon}{\isacharcolon}\ {\isachardoublequoteopen}\ int\ {\isasymRightarrow}{\isacharparenleft}bitU{\isacharparenright}list\ {\isasymRightarrow}{\isacharparenleft}bitU{\isacharparenright}list\ {\isachardoublequoteclose}\ \ \isakeyword{where}\ \isanewline
+\ \ \ \ \ {\isachardoublequoteopen}\ sub{\isacharunderscore}int{\isacharunderscore}vec\ \ \ l\ r\ {\isacharequal}\ {\isacharparenleft}\ arith{\isacharunderscore}op{\isacharunderscore}int{\isacharunderscore}bv\ \isanewline
+\ \ {\isacharparenleft}instance{\isacharunderscore}Sail{\isadigit{2}}{\isacharunderscore}values{\isacharunderscore}Bitvector{\isacharunderscore}list{\isacharunderscore}dict\isanewline
+\ \ \ \ \ instance{\isacharunderscore}Sail{\isadigit{2}}{\isacharunderscore}values{\isacharunderscore}BitU{\isacharunderscore}Sail{\isadigit{2}}{\isacharunderscore}values{\isacharunderscore}bitU{\isacharunderscore}dict{\isacharparenright}\ {\isacharparenleft}{\isacharminus}{\isacharparenright}\ False\ l\ r\ {\isacharparenright}{\isachardoublequoteclose}\isanewline
+\isanewline
+\isacommand{definition}\isamarkupfalse%
+\ mult{\isacharunderscore}int{\isacharunderscore}vec\ \ {\isacharcolon}{\isacharcolon}\ {\isachardoublequoteopen}\ int\ {\isasymRightarrow}{\isacharparenleft}bitU{\isacharparenright}list\ {\isasymRightarrow}{\isacharparenleft}bitU{\isacharparenright}list\ {\isachardoublequoteclose}\ \ \isakeyword{where}\ \isanewline
+\ \ \ \ \ {\isachardoublequoteopen}\ mult{\isacharunderscore}int{\isacharunderscore}vec\ \ l\ r\ {\isacharequal}\ {\isacharparenleft}\ arith{\isacharunderscore}op{\isacharunderscore}double{\isacharunderscore}bl\ \isanewline
+\ \ {\isacharparenleft}instance{\isacharunderscore}Sail{\isadigit{2}}{\isacharunderscore}values{\isacharunderscore}Bitvector{\isacharunderscore}list{\isacharunderscore}dict\isanewline
+\ \ \ \ \ instance{\isacharunderscore}Sail{\isadigit{2}}{\isacharunderscore}values{\isacharunderscore}BitU{\isacharunderscore}Sail{\isadigit{2}}{\isacharunderscore}values{\isacharunderscore}bitU{\isacharunderscore}dict{\isacharparenright}\ {\isacharparenleft}\ {\isacharasterisk}\ {\isacharparenright}\ False\ {\isacharparenleft}List{\isachardot}map\ {\isacharparenleft}{\isasymlambda}\ b{\isachardot}\ b{\isacharparenright}\ {\isacharparenleft}bits{\isacharunderscore}of{\isacharunderscore}int\ {\isacharparenleft}int\ {\isacharparenleft}List{\isachardot}length\ r{\isacharparenright}{\isacharparenright}\ l{\isacharparenright}{\isacharparenright}\ r\ {\isacharparenright}{\isachardoublequoteclose}\isanewline
+\isanewline
+\isanewline
+%
+\isamarkupcmt{\isa{val\ add{\isacharunderscore}vec{\isacharunderscore}bit\ \ \ \ \ \ {\isacharcolon}\ list\ bitU\ {\isacharminus}{\isachargreater}\ bitU\ {\isacharminus}{\isachargreater}\ list\ bitU}%
+}\isanewline
+%
+\isamarkupcmt{\isa{val\ adds{\isacharunderscore}vec{\isacharunderscore}bit\ \ \ \ \ {\isacharcolon}\ list\ bitU\ {\isacharminus}{\isachargreater}\ bitU\ {\isacharminus}{\isachargreater}\ list\ bitU}%
+}\isanewline
+%
+\isamarkupcmt{\isa{val\ sub{\isacharunderscore}vec{\isacharunderscore}bit\ \ \ \ \ \ {\isacharcolon}\ list\ bitU\ {\isacharminus}{\isachargreater}\ bitU\ {\isacharminus}{\isachargreater}\ list\ bitU}%
+}\isanewline
+%
+\isamarkupcmt{\isa{val\ subs{\isacharunderscore}vec{\isacharunderscore}bit\ \ \ \ \ {\isacharcolon}\ list\ bitU\ {\isacharminus}{\isachargreater}\ bitU\ {\isacharminus}{\isachargreater}\ list\ bitU}%
+}\isanewline
+\isanewline
+\isacommand{definition}\isamarkupfalse%
+\ add{\isacharunderscore}vec{\isacharunderscore}bool\ \ {\isacharcolon}{\isacharcolon}\ {\isachardoublequoteopen}\ {\isacharprime}a\ Bitvector{\isacharunderscore}class\ {\isasymRightarrow}\ {\isacharprime}a\ {\isasymRightarrow}\ bool\ {\isasymRightarrow}\ {\isacharprime}a\ {\isachardoublequoteclose}\ \ \isakeyword{where}\ \isanewline
+\ \ \ \ \ {\isachardoublequoteopen}\ add{\isacharunderscore}vec{\isacharunderscore}bool\ dict{\isacharunderscore}Sail{\isadigit{2}}{\isacharunderscore}values{\isacharunderscore}Bitvector{\isacharunderscore}a\ \ \ \ \ \ \ l\ r\ {\isacharequal}\ {\isacharparenleft}\ arith{\isacharunderscore}op{\isacharunderscore}bv{\isacharunderscore}bool\ \isanewline
+\ \ dict{\isacharunderscore}Sail{\isadigit{2}}{\isacharunderscore}values{\isacharunderscore}Bitvector{\isacharunderscore}a\ {\isacharparenleft}{\isacharplus}{\isacharparenright}\ False\ l\ r\ {\isacharparenright}{\isachardoublequoteclose}\isanewline
+\isanewline
+\isacommand{definition}\isamarkupfalse%
+\ add{\isacharunderscore}vec{\isacharunderscore}bit{\isacharunderscore}maybe\ \ {\isacharcolon}{\isacharcolon}\ {\isachardoublequoteopen}\ {\isacharprime}a\ Bitvector{\isacharunderscore}class\ {\isasymRightarrow}\ {\isacharprime}a\ {\isasymRightarrow}\ bitU\ {\isasymRightarrow}\ {\isacharprime}a\ option\ {\isachardoublequoteclose}\ \ \isakeyword{where}\ \isanewline
+\ \ \ \ \ {\isachardoublequoteopen}\ add{\isacharunderscore}vec{\isacharunderscore}bit{\isacharunderscore}maybe\ dict{\isacharunderscore}Sail{\isadigit{2}}{\isacharunderscore}values{\isacharunderscore}Bitvector{\isacharunderscore}a\ \ l\ r\ {\isacharequal}\ {\isacharparenleft}\ arith{\isacharunderscore}op{\isacharunderscore}bv{\isacharunderscore}bit\ \isanewline
+\ \ dict{\isacharunderscore}Sail{\isadigit{2}}{\isacharunderscore}values{\isacharunderscore}Bitvector{\isacharunderscore}a\ {\isacharparenleft}{\isacharplus}{\isacharparenright}\ False\ l\ r\ {\isacharparenright}{\isachardoublequoteclose}\isanewline
+\isanewline
+\isacommand{definition}\isamarkupfalse%
+\ add{\isacharunderscore}vec{\isacharunderscore}bit{\isacharunderscore}fail\ \ {\isacharcolon}{\isacharcolon}\ {\isachardoublequoteopen}\ {\isacharprime}a\ Bitvector{\isacharunderscore}class\ {\isasymRightarrow}\ {\isacharprime}a\ {\isasymRightarrow}\ bitU\ {\isasymRightarrow}{\isacharparenleft}{\isacharprime}d{\isacharcomma}{\isacharprime}a{\isacharcomma}{\isacharprime}c{\isacharparenright}monad\ {\isachardoublequoteclose}\ \ \isakeyword{where}\ \isanewline
+\ \ \ \ \ {\isachardoublequoteopen}\ add{\isacharunderscore}vec{\isacharunderscore}bit{\isacharunderscore}fail\ dict{\isacharunderscore}Sail{\isadigit{2}}{\isacharunderscore}values{\isacharunderscore}Bitvector{\isacharunderscore}a\ \ \ l\ r\ {\isacharequal}\ {\isacharparenleft}\ maybe{\isacharunderscore}fail\ {\isacharparenleft}{\isacharprime}{\isacharprime}add{\isacharunderscore}vec{\isacharunderscore}bit{\isacharprime}{\isacharprime}{\isacharparenright}\ {\isacharparenleft}add{\isacharunderscore}vec{\isacharunderscore}bit{\isacharunderscore}maybe\ \isanewline
+\ \ dict{\isacharunderscore}Sail{\isadigit{2}}{\isacharunderscore}values{\isacharunderscore}Bitvector{\isacharunderscore}a\ l\ r{\isacharparenright}{\isacharparenright}{\isachardoublequoteclose}\isanewline
+\isanewline
+\isacommand{definition}\isamarkupfalse%
+\ add{\isacharunderscore}vec{\isacharunderscore}bit{\isacharunderscore}nondet\ \ {\isacharcolon}{\isacharcolon}\ {\isachardoublequoteopen}\ {\isacharprime}a\ Bitvector{\isacharunderscore}class\ {\isasymRightarrow}\ {\isacharprime}a\ {\isasymRightarrow}\ bitU\ {\isasymRightarrow}{\isacharparenleft}{\isacharprime}d{\isacharcomma}{\isacharprime}a{\isacharcomma}{\isacharprime}c{\isacharparenright}monad\ {\isachardoublequoteclose}\ \ \isakeyword{where}\ \isanewline
+\ \ \ \ \ {\isachardoublequoteopen}\ add{\isacharunderscore}vec{\isacharunderscore}bit{\isacharunderscore}nondet\ dict{\isacharunderscore}Sail{\isadigit{2}}{\isacharunderscore}values{\isacharunderscore}Bitvector{\isacharunderscore}a\ l\ r\ {\isacharequal}\ {\isacharparenleft}\ bool{\isacharunderscore}of{\isacharunderscore}bitU{\isacharunderscore}nondet\ r\ {\isasymbind}\ {\isacharparenleft}{\isasymlambda}\ r\ {\isachardot}\ \ return\ {\isacharparenleft}add{\isacharunderscore}vec{\isacharunderscore}bool\ \isanewline
+\ \ dict{\isacharunderscore}Sail{\isadigit{2}}{\isacharunderscore}values{\isacharunderscore}Bitvector{\isacharunderscore}a\ l\ r{\isacharparenright}{\isacharparenright}{\isacharparenright}{\isachardoublequoteclose}\isanewline
+\isanewline
+\isacommand{definition}\isamarkupfalse%
+\ add{\isacharunderscore}vec{\isacharunderscore}bit\ \ {\isacharcolon}{\isacharcolon}\ {\isachardoublequoteopen}{\isacharparenleft}bitU{\isacharparenright}list\ {\isasymRightarrow}\ bitU\ {\isasymRightarrow}{\isacharparenleft}bitU{\isacharparenright}list\ {\isachardoublequoteclose}\ \ \isakeyword{where}\ \isanewline
+\ \ \ \ \ {\isachardoublequoteopen}\ add{\isacharunderscore}vec{\isacharunderscore}bit\ \ \ \ \ \ \ \ l\ r\ {\isacharequal}\ {\isacharparenleft}\ case{\isacharunderscore}option\ {\isacharparenleft}repeat\ {\isacharbrackleft}BU{\isacharbrackright}\ {\isacharparenleft}int\ {\isacharparenleft}List{\isachardot}length\ l{\isacharparenright}{\isacharparenright}{\isacharparenright}\ id\ {\isacharparenleft}add{\isacharunderscore}vec{\isacharunderscore}bit{\isacharunderscore}maybe\ \isanewline
+\ \ {\isacharparenleft}instance{\isacharunderscore}Sail{\isadigit{2}}{\isacharunderscore}values{\isacharunderscore}Bitvector{\isacharunderscore}list{\isacharunderscore}dict\isanewline
+\ \ \ \ \ instance{\isacharunderscore}Sail{\isadigit{2}}{\isacharunderscore}values{\isacharunderscore}BitU{\isacharunderscore}Sail{\isadigit{2}}{\isacharunderscore}values{\isacharunderscore}bitU{\isacharunderscore}dict{\isacharparenright}\ l\ r{\isacharparenright}{\isacharparenright}{\isachardoublequoteclose}\isanewline
+\isanewline
+\isanewline
+\isacommand{definition}\isamarkupfalse%
+\ adds{\isacharunderscore}vec{\isacharunderscore}bool\ \ {\isacharcolon}{\isacharcolon}\ {\isachardoublequoteopen}\ {\isacharprime}a\ Bitvector{\isacharunderscore}class\ {\isasymRightarrow}\ {\isacharprime}a\ {\isasymRightarrow}\ bool\ {\isasymRightarrow}\ {\isacharprime}a\ {\isachardoublequoteclose}\ \ \isakeyword{where}\ \isanewline
+\ \ \ \ \ {\isachardoublequoteopen}\ adds{\isacharunderscore}vec{\isacharunderscore}bool\ dict{\isacharunderscore}Sail{\isadigit{2}}{\isacharunderscore}values{\isacharunderscore}Bitvector{\isacharunderscore}a\ \ \ \ \ \ \ l\ r\ {\isacharequal}\ {\isacharparenleft}\ arith{\isacharunderscore}op{\isacharunderscore}bv{\isacharunderscore}bool\ \isanewline
+\ \ dict{\isacharunderscore}Sail{\isadigit{2}}{\isacharunderscore}values{\isacharunderscore}Bitvector{\isacharunderscore}a\ {\isacharparenleft}{\isacharplus}{\isacharparenright}\ True\ l\ r\ {\isacharparenright}{\isachardoublequoteclose}\isanewline
+\isanewline
+\isacommand{definition}\isamarkupfalse%
+\ adds{\isacharunderscore}vec{\isacharunderscore}bit{\isacharunderscore}maybe\ \ {\isacharcolon}{\isacharcolon}\ {\isachardoublequoteopen}\ {\isacharprime}a\ Bitvector{\isacharunderscore}class\ {\isasymRightarrow}\ {\isacharprime}a\ {\isasymRightarrow}\ bitU\ {\isasymRightarrow}\ {\isacharprime}a\ option\ {\isachardoublequoteclose}\ \ \isakeyword{where}\ \isanewline
+\ \ \ \ \ {\isachardoublequoteopen}\ adds{\isacharunderscore}vec{\isacharunderscore}bit{\isacharunderscore}maybe\ dict{\isacharunderscore}Sail{\isadigit{2}}{\isacharunderscore}values{\isacharunderscore}Bitvector{\isacharunderscore}a\ \ l\ r\ {\isacharequal}\ {\isacharparenleft}\ arith{\isacharunderscore}op{\isacharunderscore}bv{\isacharunderscore}bit\ \isanewline
+\ \ dict{\isacharunderscore}Sail{\isadigit{2}}{\isacharunderscore}values{\isacharunderscore}Bitvector{\isacharunderscore}a\ {\isacharparenleft}{\isacharplus}{\isacharparenright}\ True\ l\ r\ {\isacharparenright}{\isachardoublequoteclose}\isanewline
+\isanewline
+\isacommand{definition}\isamarkupfalse%
+\ adds{\isacharunderscore}vec{\isacharunderscore}bit{\isacharunderscore}fail\ \ {\isacharcolon}{\isacharcolon}\ {\isachardoublequoteopen}\ {\isacharprime}a\ Bitvector{\isacharunderscore}class\ {\isasymRightarrow}\ {\isacharprime}a\ {\isasymRightarrow}\ bitU\ {\isasymRightarrow}{\isacharparenleft}{\isacharprime}d{\isacharcomma}{\isacharprime}a{\isacharcomma}{\isacharprime}c{\isacharparenright}monad\ {\isachardoublequoteclose}\ \ \isakeyword{where}\ \isanewline
+\ \ \ \ \ {\isachardoublequoteopen}\ adds{\isacharunderscore}vec{\isacharunderscore}bit{\isacharunderscore}fail\ dict{\isacharunderscore}Sail{\isadigit{2}}{\isacharunderscore}values{\isacharunderscore}Bitvector{\isacharunderscore}a\ \ \ l\ r\ {\isacharequal}\ {\isacharparenleft}\ maybe{\isacharunderscore}fail\ {\isacharparenleft}{\isacharprime}{\isacharprime}adds{\isacharunderscore}vec{\isacharunderscore}bit{\isacharprime}{\isacharprime}{\isacharparenright}\ {\isacharparenleft}adds{\isacharunderscore}vec{\isacharunderscore}bit{\isacharunderscore}maybe\ \isanewline
+\ \ dict{\isacharunderscore}Sail{\isadigit{2}}{\isacharunderscore}values{\isacharunderscore}Bitvector{\isacharunderscore}a\ l\ r{\isacharparenright}{\isacharparenright}{\isachardoublequoteclose}\isanewline
+\isanewline
+\isacommand{definition}\isamarkupfalse%
+\ adds{\isacharunderscore}vec{\isacharunderscore}bit{\isacharunderscore}nondet\ \ {\isacharcolon}{\isacharcolon}\ {\isachardoublequoteopen}\ {\isacharprime}a\ Bitvector{\isacharunderscore}class\ {\isasymRightarrow}\ {\isacharprime}a\ {\isasymRightarrow}\ bitU\ {\isasymRightarrow}{\isacharparenleft}{\isacharprime}d{\isacharcomma}{\isacharprime}a{\isacharcomma}{\isacharprime}c{\isacharparenright}monad\ {\isachardoublequoteclose}\ \ \isakeyword{where}\ \isanewline
+\ \ \ \ \ {\isachardoublequoteopen}\ adds{\isacharunderscore}vec{\isacharunderscore}bit{\isacharunderscore}nondet\ dict{\isacharunderscore}Sail{\isadigit{2}}{\isacharunderscore}values{\isacharunderscore}Bitvector{\isacharunderscore}a\ l\ r\ {\isacharequal}\ {\isacharparenleft}\ bool{\isacharunderscore}of{\isacharunderscore}bitU{\isacharunderscore}nondet\ r\ {\isasymbind}\ {\isacharparenleft}{\isasymlambda}\ r\ {\isachardot}\ \ return\ {\isacharparenleft}adds{\isacharunderscore}vec{\isacharunderscore}bool\ \isanewline
+\ \ dict{\isacharunderscore}Sail{\isadigit{2}}{\isacharunderscore}values{\isacharunderscore}Bitvector{\isacharunderscore}a\ l\ r{\isacharparenright}{\isacharparenright}{\isacharparenright}{\isachardoublequoteclose}\isanewline
+\isanewline
+\isacommand{definition}\isamarkupfalse%
+\ adds{\isacharunderscore}vec{\isacharunderscore}bit\ \ {\isacharcolon}{\isacharcolon}\ {\isachardoublequoteopen}{\isacharparenleft}bitU{\isacharparenright}list\ {\isasymRightarrow}\ bitU\ {\isasymRightarrow}{\isacharparenleft}bitU{\isacharparenright}list\ {\isachardoublequoteclose}\ \ \isakeyword{where}\ \isanewline
+\ \ \ \ \ {\isachardoublequoteopen}\ adds{\isacharunderscore}vec{\isacharunderscore}bit\ \ \ \ \ \ \ \ l\ r\ {\isacharequal}\ {\isacharparenleft}\ case{\isacharunderscore}option\ {\isacharparenleft}repeat\ {\isacharbrackleft}BU{\isacharbrackright}\ {\isacharparenleft}int\ {\isacharparenleft}List{\isachardot}length\ l{\isacharparenright}{\isacharparenright}{\isacharparenright}\ id\ {\isacharparenleft}adds{\isacharunderscore}vec{\isacharunderscore}bit{\isacharunderscore}maybe\ \isanewline
+\ \ {\isacharparenleft}instance{\isacharunderscore}Sail{\isadigit{2}}{\isacharunderscore}values{\isacharunderscore}Bitvector{\isacharunderscore}list{\isacharunderscore}dict\isanewline
+\ \ \ \ \ instance{\isacharunderscore}Sail{\isadigit{2}}{\isacharunderscore}values{\isacharunderscore}BitU{\isacharunderscore}Sail{\isadigit{2}}{\isacharunderscore}values{\isacharunderscore}bitU{\isacharunderscore}dict{\isacharparenright}\ l\ r{\isacharparenright}{\isacharparenright}{\isachardoublequoteclose}\isanewline
+\isanewline
+\isanewline
+\isacommand{definition}\isamarkupfalse%
+\ sub{\isacharunderscore}vec{\isacharunderscore}bool\ \ {\isacharcolon}{\isacharcolon}\ {\isachardoublequoteopen}\ {\isacharprime}a\ Bitvector{\isacharunderscore}class\ {\isasymRightarrow}\ {\isacharprime}a\ {\isasymRightarrow}\ bool\ {\isasymRightarrow}\ {\isacharprime}a\ {\isachardoublequoteclose}\ \ \isakeyword{where}\ \isanewline
+\ \ \ \ \ {\isachardoublequoteopen}\ sub{\isacharunderscore}vec{\isacharunderscore}bool\ dict{\isacharunderscore}Sail{\isadigit{2}}{\isacharunderscore}values{\isacharunderscore}Bitvector{\isacharunderscore}a\ \ \ \ \ \ \ \ l\ r\ {\isacharequal}\ {\isacharparenleft}\ arith{\isacharunderscore}op{\isacharunderscore}bv{\isacharunderscore}bool\ \isanewline
+\ \ dict{\isacharunderscore}Sail{\isadigit{2}}{\isacharunderscore}values{\isacharunderscore}Bitvector{\isacharunderscore}a\ {\isacharparenleft}{\isacharminus}{\isacharparenright}\ False\ l\ r\ {\isacharparenright}{\isachardoublequoteclose}\isanewline
+\isanewline
+\isacommand{definition}\isamarkupfalse%
+\ sub{\isacharunderscore}vec{\isacharunderscore}bit{\isacharunderscore}maybe\ \ {\isacharcolon}{\isacharcolon}\ {\isachardoublequoteopen}\ {\isacharprime}a\ Bitvector{\isacharunderscore}class\ {\isasymRightarrow}\ {\isacharprime}a\ {\isasymRightarrow}\ bitU\ {\isasymRightarrow}\ {\isacharprime}a\ option\ {\isachardoublequoteclose}\ \ \isakeyword{where}\ \isanewline
+\ \ \ \ \ {\isachardoublequoteopen}\ sub{\isacharunderscore}vec{\isacharunderscore}bit{\isacharunderscore}maybe\ dict{\isacharunderscore}Sail{\isadigit{2}}{\isacharunderscore}values{\isacharunderscore}Bitvector{\isacharunderscore}a\ \ \ l\ r\ {\isacharequal}\ {\isacharparenleft}\ arith{\isacharunderscore}op{\isacharunderscore}bv{\isacharunderscore}bit\ \isanewline
+\ \ dict{\isacharunderscore}Sail{\isadigit{2}}{\isacharunderscore}values{\isacharunderscore}Bitvector{\isacharunderscore}a\ {\isacharparenleft}{\isacharminus}{\isacharparenright}\ False\ l\ r\ {\isacharparenright}{\isachardoublequoteclose}\isanewline
+\isanewline
+\isacommand{definition}\isamarkupfalse%
+\ sub{\isacharunderscore}vec{\isacharunderscore}bit{\isacharunderscore}fail\ \ {\isacharcolon}{\isacharcolon}\ {\isachardoublequoteopen}\ {\isacharprime}a\ Bitvector{\isacharunderscore}class\ {\isasymRightarrow}\ {\isacharprime}a\ {\isasymRightarrow}\ bitU\ {\isasymRightarrow}{\isacharparenleft}{\isacharprime}d{\isacharcomma}{\isacharprime}a{\isacharcomma}{\isacharprime}c{\isacharparenright}monad\ {\isachardoublequoteclose}\ \ \isakeyword{where}\ \isanewline
+\ \ \ \ \ {\isachardoublequoteopen}\ sub{\isacharunderscore}vec{\isacharunderscore}bit{\isacharunderscore}fail\ dict{\isacharunderscore}Sail{\isadigit{2}}{\isacharunderscore}values{\isacharunderscore}Bitvector{\isacharunderscore}a\ \ \ \ l\ r\ {\isacharequal}\ {\isacharparenleft}\ maybe{\isacharunderscore}fail\ {\isacharparenleft}{\isacharprime}{\isacharprime}sub{\isacharunderscore}vec{\isacharunderscore}bit{\isacharprime}{\isacharprime}{\isacharparenright}\ {\isacharparenleft}sub{\isacharunderscore}vec{\isacharunderscore}bit{\isacharunderscore}maybe\ \isanewline
+\ \ dict{\isacharunderscore}Sail{\isadigit{2}}{\isacharunderscore}values{\isacharunderscore}Bitvector{\isacharunderscore}a\ l\ r{\isacharparenright}{\isacharparenright}{\isachardoublequoteclose}\isanewline
+\isanewline
+\isacommand{definition}\isamarkupfalse%
+\ sub{\isacharunderscore}vec{\isacharunderscore}bit{\isacharunderscore}nondet\ \ {\isacharcolon}{\isacharcolon}\ {\isachardoublequoteopen}\ {\isacharprime}a\ Bitvector{\isacharunderscore}class\ {\isasymRightarrow}\ {\isacharprime}a\ {\isasymRightarrow}\ bitU\ {\isasymRightarrow}{\isacharparenleft}{\isacharprime}d{\isacharcomma}{\isacharprime}a{\isacharcomma}{\isacharprime}c{\isacharparenright}monad\ {\isachardoublequoteclose}\ \ \isakeyword{where}\ \isanewline
+\ \ \ \ \ {\isachardoublequoteopen}\ sub{\isacharunderscore}vec{\isacharunderscore}bit{\isacharunderscore}nondet\ dict{\isacharunderscore}Sail{\isadigit{2}}{\isacharunderscore}values{\isacharunderscore}Bitvector{\isacharunderscore}a\ \ l\ r\ {\isacharequal}\ {\isacharparenleft}\ bool{\isacharunderscore}of{\isacharunderscore}bitU{\isacharunderscore}nondet\ r\ {\isasymbind}\ {\isacharparenleft}{\isasymlambda}\ r\ {\isachardot}\ \ return\ {\isacharparenleft}sub{\isacharunderscore}vec{\isacharunderscore}bool\ \isanewline
+\ \ dict{\isacharunderscore}Sail{\isadigit{2}}{\isacharunderscore}values{\isacharunderscore}Bitvector{\isacharunderscore}a\ l\ r{\isacharparenright}{\isacharparenright}{\isacharparenright}{\isachardoublequoteclose}\isanewline
+\isanewline
+\isacommand{definition}\isamarkupfalse%
+\ sub{\isacharunderscore}vec{\isacharunderscore}bit\ \ {\isacharcolon}{\isacharcolon}\ {\isachardoublequoteopen}{\isacharparenleft}bitU{\isacharparenright}list\ {\isasymRightarrow}\ bitU\ {\isasymRightarrow}{\isacharparenleft}bitU{\isacharparenright}list\ {\isachardoublequoteclose}\ \ \isakeyword{where}\ \isanewline
+\ \ \ \ \ {\isachardoublequoteopen}\ sub{\isacharunderscore}vec{\isacharunderscore}bit\ \ \ \ \ \ \ \ \ l\ r\ {\isacharequal}\ {\isacharparenleft}\ case{\isacharunderscore}option\ {\isacharparenleft}repeat\ {\isacharbrackleft}BU{\isacharbrackright}\ {\isacharparenleft}int\ {\isacharparenleft}List{\isachardot}length\ l{\isacharparenright}{\isacharparenright}{\isacharparenright}\ id\ {\isacharparenleft}sub{\isacharunderscore}vec{\isacharunderscore}bit{\isacharunderscore}maybe\ \isanewline
+\ \ {\isacharparenleft}instance{\isacharunderscore}Sail{\isadigit{2}}{\isacharunderscore}values{\isacharunderscore}Bitvector{\isacharunderscore}list{\isacharunderscore}dict\isanewline
+\ \ \ \ \ instance{\isacharunderscore}Sail{\isadigit{2}}{\isacharunderscore}values{\isacharunderscore}BitU{\isacharunderscore}Sail{\isadigit{2}}{\isacharunderscore}values{\isacharunderscore}bitU{\isacharunderscore}dict{\isacharparenright}\ l\ r{\isacharparenright}{\isacharparenright}{\isachardoublequoteclose}\isanewline
+\isanewline
+\isanewline
+\isacommand{definition}\isamarkupfalse%
+\ subs{\isacharunderscore}vec{\isacharunderscore}bool\ \ {\isacharcolon}{\isacharcolon}\ {\isachardoublequoteopen}\ {\isacharprime}a\ Bitvector{\isacharunderscore}class\ {\isasymRightarrow}\ {\isacharprime}a\ {\isasymRightarrow}\ bool\ {\isasymRightarrow}\ {\isacharprime}a\ {\isachardoublequoteclose}\ \ \isakeyword{where}\ \isanewline
+\ \ \ \ \ {\isachardoublequoteopen}\ subs{\isacharunderscore}vec{\isacharunderscore}bool\ dict{\isacharunderscore}Sail{\isadigit{2}}{\isacharunderscore}values{\isacharunderscore}Bitvector{\isacharunderscore}a\ \ \ \ \ \ \ l\ r\ {\isacharequal}\ {\isacharparenleft}\ arith{\isacharunderscore}op{\isacharunderscore}bv{\isacharunderscore}bool\ \isanewline
+\ \ dict{\isacharunderscore}Sail{\isadigit{2}}{\isacharunderscore}values{\isacharunderscore}Bitvector{\isacharunderscore}a\ {\isacharparenleft}{\isacharminus}{\isacharparenright}\ True\ l\ r\ {\isacharparenright}{\isachardoublequoteclose}\isanewline
+\isanewline
+\isacommand{definition}\isamarkupfalse%
+\ subs{\isacharunderscore}vec{\isacharunderscore}bit{\isacharunderscore}maybe\ \ {\isacharcolon}{\isacharcolon}\ {\isachardoublequoteopen}\ {\isacharprime}a\ Bitvector{\isacharunderscore}class\ {\isasymRightarrow}\ {\isacharprime}a\ {\isasymRightarrow}\ bitU\ {\isasymRightarrow}\ {\isacharprime}a\ option\ {\isachardoublequoteclose}\ \ \isakeyword{where}\ \isanewline
+\ \ \ \ \ {\isachardoublequoteopen}\ subs{\isacharunderscore}vec{\isacharunderscore}bit{\isacharunderscore}maybe\ dict{\isacharunderscore}Sail{\isadigit{2}}{\isacharunderscore}values{\isacharunderscore}Bitvector{\isacharunderscore}a\ \ l\ r\ {\isacharequal}\ {\isacharparenleft}\ arith{\isacharunderscore}op{\isacharunderscore}bv{\isacharunderscore}bit\ \isanewline
+\ \ dict{\isacharunderscore}Sail{\isadigit{2}}{\isacharunderscore}values{\isacharunderscore}Bitvector{\isacharunderscore}a\ {\isacharparenleft}{\isacharminus}{\isacharparenright}\ True\ l\ r\ {\isacharparenright}{\isachardoublequoteclose}\isanewline
+\isanewline
+\isacommand{definition}\isamarkupfalse%
+\ subs{\isacharunderscore}vec{\isacharunderscore}bit{\isacharunderscore}fail\ \ {\isacharcolon}{\isacharcolon}\ {\isachardoublequoteopen}\ {\isacharprime}a\ Bitvector{\isacharunderscore}class\ {\isasymRightarrow}\ {\isacharprime}a\ {\isasymRightarrow}\ bitU\ {\isasymRightarrow}{\isacharparenleft}{\isacharprime}d{\isacharcomma}{\isacharprime}a{\isacharcomma}{\isacharprime}c{\isacharparenright}monad\ {\isachardoublequoteclose}\ \ \isakeyword{where}\ \isanewline
+\ \ \ \ \ {\isachardoublequoteopen}\ subs{\isacharunderscore}vec{\isacharunderscore}bit{\isacharunderscore}fail\ dict{\isacharunderscore}Sail{\isadigit{2}}{\isacharunderscore}values{\isacharunderscore}Bitvector{\isacharunderscore}a\ \ \ l\ r\ {\isacharequal}\ {\isacharparenleft}\ maybe{\isacharunderscore}fail\ {\isacharparenleft}{\isacharprime}{\isacharprime}sub{\isacharunderscore}vec{\isacharunderscore}bit{\isacharprime}{\isacharprime}{\isacharparenright}\ {\isacharparenleft}subs{\isacharunderscore}vec{\isacharunderscore}bit{\isacharunderscore}maybe\ \isanewline
+\ \ dict{\isacharunderscore}Sail{\isadigit{2}}{\isacharunderscore}values{\isacharunderscore}Bitvector{\isacharunderscore}a\ l\ r{\isacharparenright}{\isacharparenright}{\isachardoublequoteclose}\isanewline
+\isanewline
+\isacommand{definition}\isamarkupfalse%
+\ subs{\isacharunderscore}vec{\isacharunderscore}bit{\isacharunderscore}nondet\ \ {\isacharcolon}{\isacharcolon}\ {\isachardoublequoteopen}\ {\isacharprime}a\ Bitvector{\isacharunderscore}class\ {\isasymRightarrow}\ {\isacharprime}a\ {\isasymRightarrow}\ bitU\ {\isasymRightarrow}{\isacharparenleft}{\isacharprime}d{\isacharcomma}{\isacharprime}a{\isacharcomma}{\isacharprime}c{\isacharparenright}monad\ {\isachardoublequoteclose}\ \ \isakeyword{where}\ \isanewline
+\ \ \ \ \ {\isachardoublequoteopen}\ subs{\isacharunderscore}vec{\isacharunderscore}bit{\isacharunderscore}nondet\ dict{\isacharunderscore}Sail{\isadigit{2}}{\isacharunderscore}values{\isacharunderscore}Bitvector{\isacharunderscore}a\ l\ r\ {\isacharequal}\ {\isacharparenleft}\ bool{\isacharunderscore}of{\isacharunderscore}bitU{\isacharunderscore}nondet\ r\ {\isasymbind}\ {\isacharparenleft}{\isasymlambda}\ r\ {\isachardot}\ \ return\ {\isacharparenleft}subs{\isacharunderscore}vec{\isacharunderscore}bool\ \isanewline
+\ \ dict{\isacharunderscore}Sail{\isadigit{2}}{\isacharunderscore}values{\isacharunderscore}Bitvector{\isacharunderscore}a\ l\ r{\isacharparenright}{\isacharparenright}{\isacharparenright}{\isachardoublequoteclose}\isanewline
+\isanewline
+\isacommand{definition}\isamarkupfalse%
+\ subs{\isacharunderscore}vec{\isacharunderscore}bit\ \ {\isacharcolon}{\isacharcolon}\ {\isachardoublequoteopen}{\isacharparenleft}bitU{\isacharparenright}list\ {\isasymRightarrow}\ bitU\ {\isasymRightarrow}{\isacharparenleft}bitU{\isacharparenright}list\ {\isachardoublequoteclose}\ \ \isakeyword{where}\ \isanewline
+\ \ \ \ \ {\isachardoublequoteopen}\ subs{\isacharunderscore}vec{\isacharunderscore}bit\ \ \ \ \ \ \ \ l\ r\ {\isacharequal}\ {\isacharparenleft}\ case{\isacharunderscore}option\ {\isacharparenleft}repeat\ {\isacharbrackleft}BU{\isacharbrackright}\ {\isacharparenleft}int\ {\isacharparenleft}List{\isachardot}length\ l{\isacharparenright}{\isacharparenright}{\isacharparenright}\ id\ {\isacharparenleft}subs{\isacharunderscore}vec{\isacharunderscore}bit{\isacharunderscore}maybe\ \isanewline
+\ \ {\isacharparenleft}instance{\isacharunderscore}Sail{\isadigit{2}}{\isacharunderscore}values{\isacharunderscore}Bitvector{\isacharunderscore}list{\isacharunderscore}dict\isanewline
+\ \ \ \ \ instance{\isacharunderscore}Sail{\isadigit{2}}{\isacharunderscore}values{\isacharunderscore}BitU{\isacharunderscore}Sail{\isadigit{2}}{\isacharunderscore}values{\isacharunderscore}bitU{\isacharunderscore}dict{\isacharparenright}\ l\ r{\isacharparenright}{\isacharparenright}{\isachardoublequoteclose}\isanewline
+\isanewline
+\isanewline
+%
+\isamarkupcmt{\isa{val\ add{\isacharunderscore}overflow{\isacharunderscore}vec\ \ \ \ \ \ \ \ \ {\isacharcolon}\ list\ bitU\ {\isacharminus}{\isachargreater}\ list\ bitU\ {\isacharminus}{\isachargreater}\ {\isacharparenleft}list\ bitU\ {\isacharasterisk}\ bitU\ {\isacharasterisk}\ bitU{\isacharparenright}\ val\ add{\isacharunderscore}overflow{\isacharunderscore}vec{\isacharunderscore}signed\ \ {\isacharcolon}\ list\ bitU\ {\isacharminus}{\isachargreater}\ list\ bitU\ {\isacharminus}{\isachargreater}\ {\isacharparenleft}list\ bitU\ {\isacharasterisk}\ bitU\ {\isacharasterisk}\ bitU{\isacharparenright}\ val\ sub{\isacharunderscore}overflow{\isacharunderscore}vec\ \ \ \ \ \ \ \ \ {\isacharcolon}\ list\ bitU\ {\isacharminus}{\isachargreater}\ list\ bitU\ {\isacharminus}{\isachargreater}\ {\isacharparenleft}list\ bitU\ {\isacharasterisk}\ bitU\ {\isacharasterisk}\ bitU{\isacharparenright}\ val\ sub{\isacharunderscore}overflow{\isacharunderscore}vec{\isacharunderscore}signed\ \ {\isacharcolon}\ list\ bitU\ {\isacharminus}{\isachargreater}\ list\ bitU\ {\isacharminus}{\isachargreater}\ {\isacharparenleft}list\ bitU\ {\isacharasterisk}\ bitU\ {\isacharasterisk}\ bitU{\isacharparenright}\ val\ mult{\isacharunderscore}overflow{\isacharunderscore}vec\ \ \ \ \ \ \ \ {\isacharcolon}\ list\ bitU\ {\isacharminus}{\isachargreater}\ list\ bitU\ {\isacharminus}{\isachargreater}\ {\isacharparenleft}list\ bitU\ {\isacharasterisk}\ bitU\ {\isacharasterisk}\ bitU{\isacharparenright}\ val\ mult{\isacharunderscore}overflow{\isacharunderscore}vec{\isacharunderscore}signed\ {\isacharcolon}\ list\ bitU\ {\isacharminus}{\isachargreater}\ list\ bitU\ {\isacharminus}{\isachargreater}\ {\isacharparenleft}list\ bitU\ {\isacharasterisk}\ bitU\ {\isacharasterisk}\ bitU{\isacharparenright}\ let\ add{\isacharunderscore}overflow{\isacharunderscore}vec\ \ \ \ \ \ \ \ \ {\isacharequal}\ add{\isacharunderscore}overflow{\isacharunderscore}bv\ let\ add{\isacharunderscore}overflow{\isacharunderscore}vec{\isacharunderscore}signed\ \ {\isacharequal}\ add{\isacharunderscore}overflow{\isacharunderscore}bv{\isacharunderscore}signed\ let\ sub{\isacharunderscore}overflow{\isacharunderscore}vec\ \ \ \ \ \ \ \ \ {\isacharequal}\ sub{\isacharunderscore}overflow{\isacharunderscore}bv\ let\ sub{\isacharunderscore}overflow{\isacharunderscore}vec{\isacharunderscore}signed\ \ {\isacharequal}\ sub{\isacharunderscore}overflow{\isacharunderscore}bv{\isacharunderscore}signed\ let\ mult{\isacharunderscore}overflow{\isacharunderscore}vec\ \ \ \ \ \ \ \ {\isacharequal}\ mult{\isacharunderscore}overflow{\isacharunderscore}bv\ let\ mult{\isacharunderscore}overflow{\isacharunderscore}vec{\isacharunderscore}signed\ {\isacharequal}\ mult{\isacharunderscore}overflow{\isacharunderscore}bv{\isacharunderscore}signed\ \ val\ add{\isacharunderscore}overflow{\isacharunderscore}vec{\isacharunderscore}bit\ \ \ \ \ \ \ \ \ {\isacharcolon}\ list\ bitU\ {\isacharminus}{\isachargreater}\ bitU\ {\isacharminus}{\isachargreater}\ {\isacharparenleft}list\ bitU\ {\isacharasterisk}\ bitU\ {\isacharasterisk}\ bitU{\isacharparenright}\ val\ add{\isacharunderscore}overflow{\isacharunderscore}vec{\isacharunderscore}bit{\isacharunderscore}signed\ \ {\isacharcolon}\ list\ bitU\ {\isacharminus}{\isachargreater}\ bitU\ {\isacharminus}{\isachargreater}\ {\isacharparenleft}list\ bitU\ {\isacharasterisk}\ bitU\ {\isacharasterisk}\ bitU{\isacharparenright}\ val\ sub{\isacharunderscore}overflow{\isacharunderscore}vec{\isacharunderscore}bit\ \ \ \ \ \ \ \ \ {\isacharcolon}\ list\ bitU\ {\isacharminus}{\isachargreater}\ bitU\ {\isacharminus}{\isachargreater}\ {\isacharparenleft}list\ bitU\ {\isacharasterisk}\ bitU\ {\isacharasterisk}\ bitU{\isacharparenright}\ val\ sub{\isacharunderscore}overflow{\isacharunderscore}vec{\isacharunderscore}bit{\isacharunderscore}signed\ \ {\isacharcolon}\ list\ bitU\ {\isacharminus}{\isachargreater}\ bitU\ {\isacharminus}{\isachargreater}\ {\isacharparenleft}list\ bitU\ {\isacharasterisk}\ bitU\ {\isacharasterisk}\ bitU{\isacharparenright}\ let\ add{\isacharunderscore}overflow{\isacharunderscore}vec{\isacharunderscore}bit\ \ \ \ \ \ \ \ \ {\isacharequal}\ add{\isacharunderscore}overflow{\isacharunderscore}bv{\isacharunderscore}bit\ let\ add{\isacharunderscore}overflow{\isacharunderscore}vec{\isacharunderscore}bit{\isacharunderscore}signed\ \ {\isacharequal}\ add{\isacharunderscore}overflow{\isacharunderscore}bv{\isacharunderscore}bit{\isacharunderscore}signed\ let\ sub{\isacharunderscore}overflow{\isacharunderscore}vec{\isacharunderscore}bit\ \ \ \ \ \ \ \ \ {\isacharequal}\ sub{\isacharunderscore}overflow{\isacharunderscore}bv{\isacharunderscore}bit\ let\ sub{\isacharunderscore}overflow{\isacharunderscore}vec{\isacharunderscore}bit{\isacharunderscore}signed\ \ {\isacharequal}\ sub{\isacharunderscore}overflow{\isacharunderscore}bv{\isacharunderscore}bit{\isacharunderscore}signed}%
+}\isanewline
+\isanewline
+%
+\isamarkupcmt{\isa{val\ shiftl\ \ \ \ \ \ \ {\isacharcolon}\ list\ bitU\ {\isacharminus}{\isachargreater}\ integer\ {\isacharminus}{\isachargreater}\ list\ bitU}%
+}\isanewline
+%
+\isamarkupcmt{\isa{val\ shiftr\ \ \ \ \ \ \ {\isacharcolon}\ list\ bitU\ {\isacharminus}{\isachargreater}\ integer\ {\isacharminus}{\isachargreater}\ list\ bitU}%
+}\isanewline
+%
+\isamarkupcmt{\isa{val\ arith{\isacharunderscore}shiftr\ {\isacharcolon}\ list\ bitU\ {\isacharminus}{\isachargreater}\ integer\ {\isacharminus}{\isachargreater}\ list\ bitU}%
+}\isanewline
+%
+\isamarkupcmt{\isa{val\ rotl\ \ \ \ \ \ \ \ \ {\isacharcolon}\ list\ bitU\ {\isacharminus}{\isachargreater}\ integer\ {\isacharminus}{\isachargreater}\ list\ bitU}%
+}\isanewline
+%
+\isamarkupcmt{\isa{val\ rotr\ \ \ \ \ \ \ \ \ {\isacharcolon}\ list\ bitU\ {\isacharminus}{\isachargreater}\ integer\ {\isacharminus}{\isachargreater}\ list\ bitU}%
+}\isanewline
+\isacommand{definition}\isamarkupfalse%
+\ shiftl\ \ {\isacharcolon}{\isacharcolon}\ {\isachardoublequoteopen}{\isacharparenleft}bitU{\isacharparenright}list\ {\isasymRightarrow}\ int\ {\isasymRightarrow}{\isacharparenleft}bitU{\isacharparenright}list\ {\isachardoublequoteclose}\ \ \ \ \ \ \ \ \isakeyword{where}\ \isanewline
+\ \ \ \ \ {\isachardoublequoteopen}\ shiftl\ \ \ \ \ \ \ {\isacharequal}\ {\isacharparenleft}\ \isanewline
+\ \ shiftl{\isacharunderscore}bv\isanewline
+\ \ \ \ {\isacharparenleft}instance{\isacharunderscore}Sail{\isadigit{2}}{\isacharunderscore}values{\isacharunderscore}Bitvector{\isacharunderscore}list{\isacharunderscore}dict\isanewline
+\ \ \ \ \ \ \ instance{\isacharunderscore}Sail{\isadigit{2}}{\isacharunderscore}values{\isacharunderscore}BitU{\isacharunderscore}Sail{\isadigit{2}}{\isacharunderscore}values{\isacharunderscore}bitU{\isacharunderscore}dict{\isacharparenright}\ {\isacharparenright}{\isachardoublequoteclose}\isanewline
+\isanewline
+\isacommand{definition}\isamarkupfalse%
+\ shiftr\ \ {\isacharcolon}{\isacharcolon}\ {\isachardoublequoteopen}{\isacharparenleft}bitU{\isacharparenright}list\ {\isasymRightarrow}\ int\ {\isasymRightarrow}{\isacharparenleft}bitU{\isacharparenright}list\ {\isachardoublequoteclose}\ \ \ \ \ \ \ \ \isakeyword{where}\ \isanewline
+\ \ \ \ \ {\isachardoublequoteopen}\ shiftr\ \ \ \ \ \ \ {\isacharequal}\ {\isacharparenleft}\ \isanewline
+\ \ shiftr{\isacharunderscore}bv\isanewline
+\ \ \ \ {\isacharparenleft}instance{\isacharunderscore}Sail{\isadigit{2}}{\isacharunderscore}values{\isacharunderscore}Bitvector{\isacharunderscore}list{\isacharunderscore}dict\isanewline
+\ \ \ \ \ \ \ instance{\isacharunderscore}Sail{\isadigit{2}}{\isacharunderscore}values{\isacharunderscore}BitU{\isacharunderscore}Sail{\isadigit{2}}{\isacharunderscore}values{\isacharunderscore}bitU{\isacharunderscore}dict{\isacharparenright}\ {\isacharparenright}{\isachardoublequoteclose}\isanewline
+\isanewline
+\isacommand{definition}\isamarkupfalse%
+\ arith{\isacharunderscore}shiftr\ \ {\isacharcolon}{\isacharcolon}\ {\isachardoublequoteopen}{\isacharparenleft}bitU{\isacharparenright}list\ {\isasymRightarrow}\ int\ {\isasymRightarrow}{\isacharparenleft}bitU{\isacharparenright}list\ {\isachardoublequoteclose}\ \ \isakeyword{where}\ \isanewline
+\ \ \ \ \ {\isachardoublequoteopen}\ arith{\isacharunderscore}shiftr\ {\isacharequal}\ {\isacharparenleft}\ \isanewline
+\ \ arith{\isacharunderscore}shiftr{\isacharunderscore}bv\isanewline
+\ \ \ \ {\isacharparenleft}instance{\isacharunderscore}Sail{\isadigit{2}}{\isacharunderscore}values{\isacharunderscore}Bitvector{\isacharunderscore}list{\isacharunderscore}dict\isanewline
+\ \ \ \ \ \ \ instance{\isacharunderscore}Sail{\isadigit{2}}{\isacharunderscore}values{\isacharunderscore}BitU{\isacharunderscore}Sail{\isadigit{2}}{\isacharunderscore}values{\isacharunderscore}bitU{\isacharunderscore}dict{\isacharparenright}\ {\isacharparenright}{\isachardoublequoteclose}\isanewline
+\isanewline
+\isacommand{definition}\isamarkupfalse%
+\ rotl\ \ {\isacharcolon}{\isacharcolon}\ {\isachardoublequoteopen}{\isacharparenleft}bitU{\isacharparenright}list\ {\isasymRightarrow}\ int\ {\isasymRightarrow}{\isacharparenleft}bitU{\isacharparenright}list\ {\isachardoublequoteclose}\ \ \ \ \ \ \ \ \ \ \isakeyword{where}\ \isanewline
+\ \ \ \ \ {\isachardoublequoteopen}\ rotl\ \ \ \ \ \ \ \ \ {\isacharequal}\ {\isacharparenleft}\ \isanewline
+\ \ rotl{\isacharunderscore}bv\isanewline
+\ \ \ \ {\isacharparenleft}instance{\isacharunderscore}Sail{\isadigit{2}}{\isacharunderscore}values{\isacharunderscore}Bitvector{\isacharunderscore}list{\isacharunderscore}dict\isanewline
+\ \ \ \ \ \ \ instance{\isacharunderscore}Sail{\isadigit{2}}{\isacharunderscore}values{\isacharunderscore}BitU{\isacharunderscore}Sail{\isadigit{2}}{\isacharunderscore}values{\isacharunderscore}bitU{\isacharunderscore}dict{\isacharparenright}\ {\isacharparenright}{\isachardoublequoteclose}\isanewline
+\isanewline
+\isacommand{definition}\isamarkupfalse%
+\ rotr\ \ {\isacharcolon}{\isacharcolon}\ {\isachardoublequoteopen}{\isacharparenleft}bitU{\isacharparenright}list\ {\isasymRightarrow}\ int\ {\isasymRightarrow}{\isacharparenleft}bitU{\isacharparenright}list\ {\isachardoublequoteclose}\ \ \ \ \ \ \ \ \ \ \isakeyword{where}\ \isanewline
+\ \ \ \ \ {\isachardoublequoteopen}\ rotr\ \ \ \ \ \ \ \ \ {\isacharequal}\ {\isacharparenleft}\ \isanewline
+\ \ rotr{\isacharunderscore}bv\isanewline
+\ \ \ \ {\isacharparenleft}instance{\isacharunderscore}Sail{\isadigit{2}}{\isacharunderscore}values{\isacharunderscore}Bitvector{\isacharunderscore}list{\isacharunderscore}dict\isanewline
+\ \ \ \ \ \ \ instance{\isacharunderscore}Sail{\isadigit{2}}{\isacharunderscore}values{\isacharunderscore}BitU{\isacharunderscore}Sail{\isadigit{2}}{\isacharunderscore}values{\isacharunderscore}bitU{\isacharunderscore}dict{\isacharparenright}\ {\isacharparenright}{\isachardoublequoteclose}\isanewline
+\isanewline
+\isanewline
+%
+\isamarkupcmt{\isa{val\ mod{\isacharunderscore}vec\ \ \ \ \ \ \ \ {\isacharcolon}\ list\ bitU\ {\isacharminus}{\isachargreater}\ list\ bitU\ {\isacharminus}{\isachargreater}\ list\ bitU}%
+}\isanewline
+%
+\isamarkupcmt{\isa{val\ mod{\isacharunderscore}vec{\isacharunderscore}maybe\ \ {\isacharcolon}\ list\ bitU\ {\isacharminus}{\isachargreater}\ list\ bitU\ {\isacharminus}{\isachargreater}\ maybe\ {\isacharparenleft}list\ bitU{\isacharparenright}}%
+}\isanewline
+%
+\isamarkupcmt{\isa{val\ mod{\isacharunderscore}vec{\isacharunderscore}fail\ \ \ {\isacharcolon}\ forall\ {\isacharprime}rv\ {\isacharprime}e{\isachardot}\ list\ bitU\ {\isacharminus}{\isachargreater}\ list\ bitU\ {\isacharminus}{\isachargreater}\ monad\ {\isacharprime}rv\ {\isacharparenleft}list\ bitU{\isacharparenright}\ {\isacharprime}e}%
+}\isanewline
+%
+\isamarkupcmt{\isa{val\ mod{\isacharunderscore}vec{\isacharunderscore}nondet\ {\isacharcolon}\ forall\ {\isacharprime}rv\ {\isacharprime}e{\isachardot}\ list\ bitU\ {\isacharminus}{\isachargreater}\ list\ bitU\ {\isacharminus}{\isachargreater}\ monad\ {\isacharprime}rv\ {\isacharparenleft}list\ bitU{\isacharparenright}\ {\isacharprime}e}%
+}\isanewline
+\isacommand{definition}\isamarkupfalse%
+\ mod{\isacharunderscore}vec\ \ {\isacharcolon}{\isacharcolon}\ {\isachardoublequoteopen}{\isacharparenleft}bitU{\isacharparenright}list\ {\isasymRightarrow}{\isacharparenleft}bitU{\isacharparenright}list\ {\isasymRightarrow}{\isacharparenleft}bitU{\isacharparenright}list\ {\isachardoublequoteclose}\ \ \isakeyword{where}\ \isanewline
+\ \ \ \ \ {\isachardoublequoteopen}\ mod{\isacharunderscore}vec\ \ \ \ \ \ \ \ l\ r\ {\isacharequal}\ {\isacharparenleft}\ case{\isacharunderscore}option\ {\isacharparenleft}repeat\ {\isacharbrackleft}BU{\isacharbrackright}\ {\isacharparenleft}int\ {\isacharparenleft}List{\isachardot}length\ l{\isacharparenright}{\isacharparenright}{\isacharparenright}\ id\ {\isacharparenleft}mod{\isacharunderscore}bv\ \isanewline
+\ \ {\isacharparenleft}instance{\isacharunderscore}Sail{\isadigit{2}}{\isacharunderscore}values{\isacharunderscore}Bitvector{\isacharunderscore}list{\isacharunderscore}dict\isanewline
+\ \ \ \ \ instance{\isacharunderscore}Sail{\isadigit{2}}{\isacharunderscore}values{\isacharunderscore}BitU{\isacharunderscore}Sail{\isadigit{2}}{\isacharunderscore}values{\isacharunderscore}bitU{\isacharunderscore}dict{\isacharparenright}\ {\isacharparenleft}instance{\isacharunderscore}Sail{\isadigit{2}}{\isacharunderscore}values{\isacharunderscore}Bitvector{\isacharunderscore}list{\isacharunderscore}dict\isanewline
+\ \ \ instance{\isacharunderscore}Sail{\isadigit{2}}{\isacharunderscore}values{\isacharunderscore}BitU{\isacharunderscore}Sail{\isadigit{2}}{\isacharunderscore}values{\isacharunderscore}bitU{\isacharunderscore}dict{\isacharparenright}\ l\ r{\isacharparenright}{\isacharparenright}{\isachardoublequoteclose}\isanewline
+\isanewline
+\isacommand{definition}\isamarkupfalse%
+\ mod{\isacharunderscore}vec{\isacharunderscore}maybe\ \ {\isacharcolon}{\isacharcolon}\ {\isachardoublequoteopen}{\isacharparenleft}bitU{\isacharparenright}list\ {\isasymRightarrow}{\isacharparenleft}bitU{\isacharparenright}list\ {\isasymRightarrow}{\isacharparenleft}{\isacharparenleft}bitU{\isacharparenright}list{\isacharparenright}option\ {\isachardoublequoteclose}\ \ \isakeyword{where}\ \isanewline
+\ \ \ \ \ {\isachardoublequoteopen}\ mod{\isacharunderscore}vec{\isacharunderscore}maybe\ \ l\ r\ {\isacharequal}\ {\isacharparenleft}\ mod{\isacharunderscore}bv\ \isanewline
+\ \ {\isacharparenleft}instance{\isacharunderscore}Sail{\isadigit{2}}{\isacharunderscore}values{\isacharunderscore}Bitvector{\isacharunderscore}list{\isacharunderscore}dict\isanewline
+\ \ \ \ \ instance{\isacharunderscore}Sail{\isadigit{2}}{\isacharunderscore}values{\isacharunderscore}BitU{\isacharunderscore}Sail{\isadigit{2}}{\isacharunderscore}values{\isacharunderscore}bitU{\isacharunderscore}dict{\isacharparenright}\ {\isacharparenleft}instance{\isacharunderscore}Sail{\isadigit{2}}{\isacharunderscore}values{\isacharunderscore}Bitvector{\isacharunderscore}list{\isacharunderscore}dict\isanewline
+\ \ \ instance{\isacharunderscore}Sail{\isadigit{2}}{\isacharunderscore}values{\isacharunderscore}BitU{\isacharunderscore}Sail{\isadigit{2}}{\isacharunderscore}values{\isacharunderscore}bitU{\isacharunderscore}dict{\isacharparenright}\ l\ r\ {\isacharparenright}{\isachardoublequoteclose}\isanewline
+\isanewline
+\isacommand{definition}\isamarkupfalse%
+\ mod{\isacharunderscore}vec{\isacharunderscore}fail\ \ {\isacharcolon}{\isacharcolon}\ {\isachardoublequoteopen}{\isacharparenleft}bitU{\isacharparenright}list\ {\isasymRightarrow}{\isacharparenleft}bitU{\isacharparenright}list\ {\isasymRightarrow}{\isacharparenleft}{\isacharprime}rv{\isacharcomma}{\isacharparenleft}{\isacharparenleft}bitU{\isacharparenright}list{\isacharparenright}{\isacharcomma}{\isacharprime}e{\isacharparenright}monad\ {\isachardoublequoteclose}\ \ \isakeyword{where}\ \isanewline
+\ \ \ \ \ {\isachardoublequoteopen}\ mod{\isacharunderscore}vec{\isacharunderscore}fail\ \ \ l\ r\ {\isacharequal}\ {\isacharparenleft}\ maybe{\isacharunderscore}fail\ {\isacharparenleft}{\isacharprime}{\isacharprime}mod{\isacharunderscore}vec{\isacharprime}{\isacharprime}{\isacharparenright}\ {\isacharparenleft}mod{\isacharunderscore}bv\ \isanewline
+\ \ {\isacharparenleft}instance{\isacharunderscore}Sail{\isadigit{2}}{\isacharunderscore}values{\isacharunderscore}Bitvector{\isacharunderscore}list{\isacharunderscore}dict\isanewline
+\ \ \ \ \ instance{\isacharunderscore}Sail{\isadigit{2}}{\isacharunderscore}values{\isacharunderscore}BitU{\isacharunderscore}Sail{\isadigit{2}}{\isacharunderscore}values{\isacharunderscore}bitU{\isacharunderscore}dict{\isacharparenright}\ {\isacharparenleft}instance{\isacharunderscore}Sail{\isadigit{2}}{\isacharunderscore}values{\isacharunderscore}Bitvector{\isacharunderscore}list{\isacharunderscore}dict\isanewline
+\ \ \ instance{\isacharunderscore}Sail{\isadigit{2}}{\isacharunderscore}values{\isacharunderscore}BitU{\isacharunderscore}Sail{\isadigit{2}}{\isacharunderscore}values{\isacharunderscore}bitU{\isacharunderscore}dict{\isacharparenright}\ l\ r{\isacharparenright}{\isacharparenright}{\isachardoublequoteclose}\isanewline
+\isanewline
+\isacommand{definition}\isamarkupfalse%
+\ mod{\isacharunderscore}vec{\isacharunderscore}nondet\ \ {\isacharcolon}{\isacharcolon}\ {\isachardoublequoteopen}{\isacharparenleft}bitU{\isacharparenright}list\ {\isasymRightarrow}{\isacharparenleft}bitU{\isacharparenright}list\ {\isasymRightarrow}{\isacharparenleft}{\isacharprime}rv{\isacharcomma}{\isacharparenleft}{\isacharparenleft}bitU{\isacharparenright}list{\isacharparenright}{\isacharcomma}{\isacharprime}e{\isacharparenright}monad\ {\isachardoublequoteclose}\ \ \isakeyword{where}\ \isanewline
+\ \ \ \ \ {\isachardoublequoteopen}\ mod{\isacharunderscore}vec{\isacharunderscore}nondet\ l\ r\ {\isacharequal}\ {\isacharparenleft}\ of{\isacharunderscore}bits{\isacharunderscore}nondet\ \isanewline
+\ \ {\isacharparenleft}instance{\isacharunderscore}Sail{\isadigit{2}}{\isacharunderscore}values{\isacharunderscore}Bitvector{\isacharunderscore}list{\isacharunderscore}dict\isanewline
+\ \ \ \ \ instance{\isacharunderscore}Sail{\isadigit{2}}{\isacharunderscore}values{\isacharunderscore}BitU{\isacharunderscore}Sail{\isadigit{2}}{\isacharunderscore}values{\isacharunderscore}bitU{\isacharunderscore}dict{\isacharparenright}\ {\isacharparenleft}mod{\isacharunderscore}vec\ l\ r{\isacharparenright}{\isacharparenright}{\isachardoublequoteclose}\isanewline
+\isanewline
+\isanewline
+%
+\isamarkupcmt{\isa{val\ quot{\isacharunderscore}vec\ \ \ \ \ \ \ \ {\isacharcolon}\ list\ bitU\ {\isacharminus}{\isachargreater}\ list\ bitU\ {\isacharminus}{\isachargreater}\ list\ bitU}%
+}\isanewline
+%
+\isamarkupcmt{\isa{val\ quot{\isacharunderscore}vec{\isacharunderscore}maybe\ \ {\isacharcolon}\ list\ bitU\ {\isacharminus}{\isachargreater}\ list\ bitU\ {\isacharminus}{\isachargreater}\ maybe\ {\isacharparenleft}list\ bitU{\isacharparenright}}%
+}\isanewline
+%
+\isamarkupcmt{\isa{val\ quot{\isacharunderscore}vec{\isacharunderscore}fail\ \ \ {\isacharcolon}\ forall\ {\isacharprime}rv\ {\isacharprime}e{\isachardot}\ list\ bitU\ {\isacharminus}{\isachargreater}\ list\ bitU\ {\isacharminus}{\isachargreater}\ monad\ {\isacharprime}rv\ {\isacharparenleft}list\ bitU{\isacharparenright}\ {\isacharprime}e}%
+}\isanewline
+%
+\isamarkupcmt{\isa{val\ quot{\isacharunderscore}vec{\isacharunderscore}nondet\ {\isacharcolon}\ forall\ {\isacharprime}rv\ {\isacharprime}e{\isachardot}\ list\ bitU\ {\isacharminus}{\isachargreater}\ list\ bitU\ {\isacharminus}{\isachargreater}\ monad\ {\isacharprime}rv\ {\isacharparenleft}list\ bitU{\isacharparenright}\ {\isacharprime}e}%
+}\isanewline
+\isacommand{definition}\isamarkupfalse%
+\ quot{\isacharunderscore}vec\ \ {\isacharcolon}{\isacharcolon}\ {\isachardoublequoteopen}{\isacharparenleft}bitU{\isacharparenright}list\ {\isasymRightarrow}{\isacharparenleft}bitU{\isacharparenright}list\ {\isasymRightarrow}{\isacharparenleft}bitU{\isacharparenright}list\ {\isachardoublequoteclose}\ \ \isakeyword{where}\ \isanewline
+\ \ \ \ \ {\isachardoublequoteopen}\ quot{\isacharunderscore}vec\ \ \ \ \ \ \ \ l\ r\ {\isacharequal}\ {\isacharparenleft}\ case{\isacharunderscore}option\ {\isacharparenleft}repeat\ {\isacharbrackleft}BU{\isacharbrackright}\ {\isacharparenleft}int\ {\isacharparenleft}List{\isachardot}length\ l{\isacharparenright}{\isacharparenright}{\isacharparenright}\ id\ {\isacharparenleft}quot{\isacharunderscore}bv\ \isanewline
+\ \ {\isacharparenleft}instance{\isacharunderscore}Sail{\isadigit{2}}{\isacharunderscore}values{\isacharunderscore}Bitvector{\isacharunderscore}list{\isacharunderscore}dict\isanewline
+\ \ \ \ \ instance{\isacharunderscore}Sail{\isadigit{2}}{\isacharunderscore}values{\isacharunderscore}BitU{\isacharunderscore}Sail{\isadigit{2}}{\isacharunderscore}values{\isacharunderscore}bitU{\isacharunderscore}dict{\isacharparenright}\ {\isacharparenleft}instance{\isacharunderscore}Sail{\isadigit{2}}{\isacharunderscore}values{\isacharunderscore}Bitvector{\isacharunderscore}list{\isacharunderscore}dict\isanewline
+\ \ \ instance{\isacharunderscore}Sail{\isadigit{2}}{\isacharunderscore}values{\isacharunderscore}BitU{\isacharunderscore}Sail{\isadigit{2}}{\isacharunderscore}values{\isacharunderscore}bitU{\isacharunderscore}dict{\isacharparenright}\ l\ r{\isacharparenright}{\isacharparenright}{\isachardoublequoteclose}\isanewline
+\isanewline
+\isacommand{definition}\isamarkupfalse%
+\ quot{\isacharunderscore}vec{\isacharunderscore}maybe\ \ {\isacharcolon}{\isacharcolon}\ {\isachardoublequoteopen}{\isacharparenleft}bitU{\isacharparenright}list\ {\isasymRightarrow}{\isacharparenleft}bitU{\isacharparenright}list\ {\isasymRightarrow}{\isacharparenleft}{\isacharparenleft}bitU{\isacharparenright}list{\isacharparenright}option\ {\isachardoublequoteclose}\ \ \isakeyword{where}\ \isanewline
+\ \ \ \ \ {\isachardoublequoteopen}\ quot{\isacharunderscore}vec{\isacharunderscore}maybe\ \ l\ r\ {\isacharequal}\ {\isacharparenleft}\ quot{\isacharunderscore}bv\ \isanewline
+\ \ {\isacharparenleft}instance{\isacharunderscore}Sail{\isadigit{2}}{\isacharunderscore}values{\isacharunderscore}Bitvector{\isacharunderscore}list{\isacharunderscore}dict\isanewline
+\ \ \ \ \ instance{\isacharunderscore}Sail{\isadigit{2}}{\isacharunderscore}values{\isacharunderscore}BitU{\isacharunderscore}Sail{\isadigit{2}}{\isacharunderscore}values{\isacharunderscore}bitU{\isacharunderscore}dict{\isacharparenright}\ {\isacharparenleft}instance{\isacharunderscore}Sail{\isadigit{2}}{\isacharunderscore}values{\isacharunderscore}Bitvector{\isacharunderscore}list{\isacharunderscore}dict\isanewline
+\ \ \ instance{\isacharunderscore}Sail{\isadigit{2}}{\isacharunderscore}values{\isacharunderscore}BitU{\isacharunderscore}Sail{\isadigit{2}}{\isacharunderscore}values{\isacharunderscore}bitU{\isacharunderscore}dict{\isacharparenright}\ l\ r\ {\isacharparenright}{\isachardoublequoteclose}\isanewline
+\isanewline
+\isacommand{definition}\isamarkupfalse%
+\ quot{\isacharunderscore}vec{\isacharunderscore}fail\ \ {\isacharcolon}{\isacharcolon}\ {\isachardoublequoteopen}{\isacharparenleft}bitU{\isacharparenright}list\ {\isasymRightarrow}{\isacharparenleft}bitU{\isacharparenright}list\ {\isasymRightarrow}{\isacharparenleft}{\isacharprime}rv{\isacharcomma}{\isacharparenleft}{\isacharparenleft}bitU{\isacharparenright}list{\isacharparenright}{\isacharcomma}{\isacharprime}e{\isacharparenright}monad\ {\isachardoublequoteclose}\ \ \isakeyword{where}\ \isanewline
+\ \ \ \ \ {\isachardoublequoteopen}\ quot{\isacharunderscore}vec{\isacharunderscore}fail\ \ \ l\ r\ {\isacharequal}\ {\isacharparenleft}\ maybe{\isacharunderscore}fail\ {\isacharparenleft}{\isacharprime}{\isacharprime}quot{\isacharunderscore}vec{\isacharprime}{\isacharprime}{\isacharparenright}\ {\isacharparenleft}quot{\isacharunderscore}bv\ \isanewline
+\ \ {\isacharparenleft}instance{\isacharunderscore}Sail{\isadigit{2}}{\isacharunderscore}values{\isacharunderscore}Bitvector{\isacharunderscore}list{\isacharunderscore}dict\isanewline
+\ \ \ \ \ instance{\isacharunderscore}Sail{\isadigit{2}}{\isacharunderscore}values{\isacharunderscore}BitU{\isacharunderscore}Sail{\isadigit{2}}{\isacharunderscore}values{\isacharunderscore}bitU{\isacharunderscore}dict{\isacharparenright}\ {\isacharparenleft}instance{\isacharunderscore}Sail{\isadigit{2}}{\isacharunderscore}values{\isacharunderscore}Bitvector{\isacharunderscore}list{\isacharunderscore}dict\isanewline
+\ \ \ instance{\isacharunderscore}Sail{\isadigit{2}}{\isacharunderscore}values{\isacharunderscore}BitU{\isacharunderscore}Sail{\isadigit{2}}{\isacharunderscore}values{\isacharunderscore}bitU{\isacharunderscore}dict{\isacharparenright}\ l\ r{\isacharparenright}{\isacharparenright}{\isachardoublequoteclose}\isanewline
+\isanewline
+\isacommand{definition}\isamarkupfalse%
+\ quot{\isacharunderscore}vec{\isacharunderscore}nondet\ \ {\isacharcolon}{\isacharcolon}\ {\isachardoublequoteopen}{\isacharparenleft}bitU{\isacharparenright}list\ {\isasymRightarrow}{\isacharparenleft}bitU{\isacharparenright}list\ {\isasymRightarrow}{\isacharparenleft}{\isacharprime}rv{\isacharcomma}{\isacharparenleft}{\isacharparenleft}bitU{\isacharparenright}list{\isacharparenright}{\isacharcomma}{\isacharprime}e{\isacharparenright}monad\ {\isachardoublequoteclose}\ \ \isakeyword{where}\ \isanewline
+\ \ \ \ \ {\isachardoublequoteopen}\ quot{\isacharunderscore}vec{\isacharunderscore}nondet\ l\ r\ {\isacharequal}\ {\isacharparenleft}\ of{\isacharunderscore}bits{\isacharunderscore}nondet\ \isanewline
+\ \ {\isacharparenleft}instance{\isacharunderscore}Sail{\isadigit{2}}{\isacharunderscore}values{\isacharunderscore}Bitvector{\isacharunderscore}list{\isacharunderscore}dict\isanewline
+\ \ \ \ \ instance{\isacharunderscore}Sail{\isadigit{2}}{\isacharunderscore}values{\isacharunderscore}BitU{\isacharunderscore}Sail{\isadigit{2}}{\isacharunderscore}values{\isacharunderscore}bitU{\isacharunderscore}dict{\isacharparenright}\ {\isacharparenleft}quot{\isacharunderscore}vec\ l\ r{\isacharparenright}{\isacharparenright}{\isachardoublequoteclose}\isanewline
+\isanewline
+\isanewline
+%
+\isamarkupcmt{\isa{val\ quots{\isacharunderscore}vec\ \ \ \ \ \ \ \ {\isacharcolon}\ list\ bitU\ {\isacharminus}{\isachargreater}\ list\ bitU\ {\isacharminus}{\isachargreater}\ list\ bitU}%
+}\isanewline
+%
+\isamarkupcmt{\isa{val\ quots{\isacharunderscore}vec{\isacharunderscore}maybe\ \ {\isacharcolon}\ list\ bitU\ {\isacharminus}{\isachargreater}\ list\ bitU\ {\isacharminus}{\isachargreater}\ maybe\ {\isacharparenleft}list\ bitU{\isacharparenright}}%
+}\isanewline
+%
+\isamarkupcmt{\isa{val\ quots{\isacharunderscore}vec{\isacharunderscore}fail\ \ \ {\isacharcolon}\ forall\ {\isacharprime}rv\ {\isacharprime}e{\isachardot}\ list\ bitU\ {\isacharminus}{\isachargreater}\ list\ bitU\ {\isacharminus}{\isachargreater}\ monad\ {\isacharprime}rv\ {\isacharparenleft}list\ bitU{\isacharparenright}\ {\isacharprime}e}%
+}\isanewline
+%
+\isamarkupcmt{\isa{val\ quots{\isacharunderscore}vec{\isacharunderscore}nondet\ {\isacharcolon}\ forall\ {\isacharprime}rv\ {\isacharprime}e{\isachardot}\ list\ bitU\ {\isacharminus}{\isachargreater}\ list\ bitU\ {\isacharminus}{\isachargreater}\ monad\ {\isacharprime}rv\ {\isacharparenleft}list\ bitU{\isacharparenright}\ {\isacharprime}e}%
+}\isanewline
+\isacommand{definition}\isamarkupfalse%
+\ quots{\isacharunderscore}vec\ \ {\isacharcolon}{\isacharcolon}\ {\isachardoublequoteopen}{\isacharparenleft}bitU{\isacharparenright}list\ {\isasymRightarrow}{\isacharparenleft}bitU{\isacharparenright}list\ {\isasymRightarrow}{\isacharparenleft}bitU{\isacharparenright}list\ {\isachardoublequoteclose}\ \ \isakeyword{where}\ \isanewline
+\ \ \ \ \ {\isachardoublequoteopen}\ quots{\isacharunderscore}vec\ \ \ \ \ \ \ \ l\ r\ {\isacharequal}\ {\isacharparenleft}\ case{\isacharunderscore}option\ {\isacharparenleft}repeat\ {\isacharbrackleft}BU{\isacharbrackright}\ {\isacharparenleft}int\ {\isacharparenleft}List{\isachardot}length\ l{\isacharparenright}{\isacharparenright}{\isacharparenright}\ id\ {\isacharparenleft}quots{\isacharunderscore}bv\ \isanewline
+\ \ {\isacharparenleft}instance{\isacharunderscore}Sail{\isadigit{2}}{\isacharunderscore}values{\isacharunderscore}Bitvector{\isacharunderscore}list{\isacharunderscore}dict\isanewline
+\ \ \ \ \ instance{\isacharunderscore}Sail{\isadigit{2}}{\isacharunderscore}values{\isacharunderscore}BitU{\isacharunderscore}Sail{\isadigit{2}}{\isacharunderscore}values{\isacharunderscore}bitU{\isacharunderscore}dict{\isacharparenright}\ {\isacharparenleft}instance{\isacharunderscore}Sail{\isadigit{2}}{\isacharunderscore}values{\isacharunderscore}Bitvector{\isacharunderscore}list{\isacharunderscore}dict\isanewline
+\ \ \ instance{\isacharunderscore}Sail{\isadigit{2}}{\isacharunderscore}values{\isacharunderscore}BitU{\isacharunderscore}Sail{\isadigit{2}}{\isacharunderscore}values{\isacharunderscore}bitU{\isacharunderscore}dict{\isacharparenright}\ l\ r{\isacharparenright}{\isacharparenright}{\isachardoublequoteclose}\isanewline
+\isanewline
+\isacommand{definition}\isamarkupfalse%
+\ quots{\isacharunderscore}vec{\isacharunderscore}maybe\ \ {\isacharcolon}{\isacharcolon}\ {\isachardoublequoteopen}{\isacharparenleft}bitU{\isacharparenright}list\ {\isasymRightarrow}{\isacharparenleft}bitU{\isacharparenright}list\ {\isasymRightarrow}{\isacharparenleft}{\isacharparenleft}bitU{\isacharparenright}list{\isacharparenright}option\ {\isachardoublequoteclose}\ \ \isakeyword{where}\ \isanewline
+\ \ \ \ \ {\isachardoublequoteopen}\ quots{\isacharunderscore}vec{\isacharunderscore}maybe\ \ l\ r\ {\isacharequal}\ {\isacharparenleft}\ quots{\isacharunderscore}bv\ \isanewline
+\ \ {\isacharparenleft}instance{\isacharunderscore}Sail{\isadigit{2}}{\isacharunderscore}values{\isacharunderscore}Bitvector{\isacharunderscore}list{\isacharunderscore}dict\isanewline
+\ \ \ \ \ instance{\isacharunderscore}Sail{\isadigit{2}}{\isacharunderscore}values{\isacharunderscore}BitU{\isacharunderscore}Sail{\isadigit{2}}{\isacharunderscore}values{\isacharunderscore}bitU{\isacharunderscore}dict{\isacharparenright}\ {\isacharparenleft}instance{\isacharunderscore}Sail{\isadigit{2}}{\isacharunderscore}values{\isacharunderscore}Bitvector{\isacharunderscore}list{\isacharunderscore}dict\isanewline
+\ \ \ instance{\isacharunderscore}Sail{\isadigit{2}}{\isacharunderscore}values{\isacharunderscore}BitU{\isacharunderscore}Sail{\isadigit{2}}{\isacharunderscore}values{\isacharunderscore}bitU{\isacharunderscore}dict{\isacharparenright}\ l\ r\ {\isacharparenright}{\isachardoublequoteclose}\isanewline
+\isanewline
+\isacommand{definition}\isamarkupfalse%
+\ quots{\isacharunderscore}vec{\isacharunderscore}fail\ \ {\isacharcolon}{\isacharcolon}\ {\isachardoublequoteopen}{\isacharparenleft}bitU{\isacharparenright}list\ {\isasymRightarrow}{\isacharparenleft}bitU{\isacharparenright}list\ {\isasymRightarrow}{\isacharparenleft}{\isacharprime}rv{\isacharcomma}{\isacharparenleft}{\isacharparenleft}bitU{\isacharparenright}list{\isacharparenright}{\isacharcomma}{\isacharprime}e{\isacharparenright}monad\ {\isachardoublequoteclose}\ \ \isakeyword{where}\ \isanewline
+\ \ \ \ \ {\isachardoublequoteopen}\ quots{\isacharunderscore}vec{\isacharunderscore}fail\ \ \ l\ r\ {\isacharequal}\ {\isacharparenleft}\ maybe{\isacharunderscore}fail\ {\isacharparenleft}{\isacharprime}{\isacharprime}quots{\isacharunderscore}vec{\isacharprime}{\isacharprime}{\isacharparenright}\ {\isacharparenleft}quots{\isacharunderscore}bv\ \isanewline
+\ \ {\isacharparenleft}instance{\isacharunderscore}Sail{\isadigit{2}}{\isacharunderscore}values{\isacharunderscore}Bitvector{\isacharunderscore}list{\isacharunderscore}dict\isanewline
+\ \ \ \ \ instance{\isacharunderscore}Sail{\isadigit{2}}{\isacharunderscore}values{\isacharunderscore}BitU{\isacharunderscore}Sail{\isadigit{2}}{\isacharunderscore}values{\isacharunderscore}bitU{\isacharunderscore}dict{\isacharparenright}\ {\isacharparenleft}instance{\isacharunderscore}Sail{\isadigit{2}}{\isacharunderscore}values{\isacharunderscore}Bitvector{\isacharunderscore}list{\isacharunderscore}dict\isanewline
+\ \ \ instance{\isacharunderscore}Sail{\isadigit{2}}{\isacharunderscore}values{\isacharunderscore}BitU{\isacharunderscore}Sail{\isadigit{2}}{\isacharunderscore}values{\isacharunderscore}bitU{\isacharunderscore}dict{\isacharparenright}\ l\ r{\isacharparenright}{\isacharparenright}{\isachardoublequoteclose}\isanewline
+\isanewline
+\isacommand{definition}\isamarkupfalse%
+\ quots{\isacharunderscore}vec{\isacharunderscore}nondet\ \ {\isacharcolon}{\isacharcolon}\ {\isachardoublequoteopen}{\isacharparenleft}bitU{\isacharparenright}list\ {\isasymRightarrow}{\isacharparenleft}bitU{\isacharparenright}list\ {\isasymRightarrow}{\isacharparenleft}{\isacharprime}rv{\isacharcomma}{\isacharparenleft}{\isacharparenleft}bitU{\isacharparenright}list{\isacharparenright}{\isacharcomma}{\isacharprime}e{\isacharparenright}monad\ {\isachardoublequoteclose}\ \ \isakeyword{where}\ \isanewline
+\ \ \ \ \ {\isachardoublequoteopen}\ quots{\isacharunderscore}vec{\isacharunderscore}nondet\ l\ r\ {\isacharequal}\ {\isacharparenleft}\ of{\isacharunderscore}bits{\isacharunderscore}nondet\ \isanewline
+\ \ {\isacharparenleft}instance{\isacharunderscore}Sail{\isadigit{2}}{\isacharunderscore}values{\isacharunderscore}Bitvector{\isacharunderscore}list{\isacharunderscore}dict\isanewline
+\ \ \ \ \ instance{\isacharunderscore}Sail{\isadigit{2}}{\isacharunderscore}values{\isacharunderscore}BitU{\isacharunderscore}Sail{\isadigit{2}}{\isacharunderscore}values{\isacharunderscore}bitU{\isacharunderscore}dict{\isacharparenright}\ {\isacharparenleft}quots{\isacharunderscore}vec\ l\ r{\isacharparenright}{\isacharparenright}{\isachardoublequoteclose}\isanewline
+\isanewline
+\isanewline
+%
+\isamarkupcmt{\isa{val\ mod{\isacharunderscore}vec{\isacharunderscore}int\ \ \ \ \ \ \ \ {\isacharcolon}\ list\ bitU\ {\isacharminus}{\isachargreater}\ integer\ {\isacharminus}{\isachargreater}\ list\ bitU}%
+}\isanewline
+%
+\isamarkupcmt{\isa{val\ mod{\isacharunderscore}vec{\isacharunderscore}int{\isacharunderscore}maybe\ \ {\isacharcolon}\ list\ bitU\ {\isacharminus}{\isachargreater}\ integer\ {\isacharminus}{\isachargreater}\ maybe\ {\isacharparenleft}list\ bitU{\isacharparenright}}%
+}\isanewline
+%
+\isamarkupcmt{\isa{val\ mod{\isacharunderscore}vec{\isacharunderscore}int{\isacharunderscore}fail\ \ \ {\isacharcolon}\ forall\ {\isacharprime}rv\ {\isacharprime}e{\isachardot}\ list\ bitU\ {\isacharminus}{\isachargreater}\ integer\ {\isacharminus}{\isachargreater}\ monad\ {\isacharprime}rv\ {\isacharparenleft}list\ bitU{\isacharparenright}\ {\isacharprime}e}%
+}\isanewline
+%
+\isamarkupcmt{\isa{val\ mod{\isacharunderscore}vec{\isacharunderscore}int{\isacharunderscore}nondet\ {\isacharcolon}\ forall\ {\isacharprime}rv\ {\isacharprime}e{\isachardot}\ list\ bitU\ {\isacharminus}{\isachargreater}\ integer\ {\isacharminus}{\isachargreater}\ monad\ {\isacharprime}rv\ {\isacharparenleft}list\ bitU{\isacharparenright}\ {\isacharprime}e}%
+}\isanewline
+\isacommand{definition}\isamarkupfalse%
+\ mod{\isacharunderscore}vec{\isacharunderscore}int\ \ {\isacharcolon}{\isacharcolon}\ {\isachardoublequoteopen}{\isacharparenleft}bitU{\isacharparenright}list\ {\isasymRightarrow}\ int\ {\isasymRightarrow}{\isacharparenleft}bitU{\isacharparenright}list\ {\isachardoublequoteclose}\ \ \isakeyword{where}\ \isanewline
+\ \ \ \ \ {\isachardoublequoteopen}\ mod{\isacharunderscore}vec{\isacharunderscore}int\ \ \ \ \ \ \ \ l\ r\ {\isacharequal}\ {\isacharparenleft}\ case{\isacharunderscore}option\ {\isacharparenleft}repeat\ {\isacharbrackleft}BU{\isacharbrackright}\ {\isacharparenleft}int\ {\isacharparenleft}List{\isachardot}length\ l{\isacharparenright}{\isacharparenright}{\isacharparenright}\ id\ {\isacharparenleft}mod{\isacharunderscore}bv{\isacharunderscore}int\ \isanewline
+\ \ {\isacharparenleft}instance{\isacharunderscore}Sail{\isadigit{2}}{\isacharunderscore}values{\isacharunderscore}Bitvector{\isacharunderscore}list{\isacharunderscore}dict\isanewline
+\ \ \ \ \ instance{\isacharunderscore}Sail{\isadigit{2}}{\isacharunderscore}values{\isacharunderscore}BitU{\isacharunderscore}Sail{\isadigit{2}}{\isacharunderscore}values{\isacharunderscore}bitU{\isacharunderscore}dict{\isacharparenright}\ {\isacharparenleft}instance{\isacharunderscore}Sail{\isadigit{2}}{\isacharunderscore}values{\isacharunderscore}Bitvector{\isacharunderscore}list{\isacharunderscore}dict\isanewline
+\ \ \ instance{\isacharunderscore}Sail{\isadigit{2}}{\isacharunderscore}values{\isacharunderscore}BitU{\isacharunderscore}Sail{\isadigit{2}}{\isacharunderscore}values{\isacharunderscore}bitU{\isacharunderscore}dict{\isacharparenright}\ l\ r{\isacharparenright}{\isacharparenright}{\isachardoublequoteclose}\isanewline
+\isanewline
+\isacommand{definition}\isamarkupfalse%
+\ mod{\isacharunderscore}vec{\isacharunderscore}int{\isacharunderscore}maybe\ \ {\isacharcolon}{\isacharcolon}\ {\isachardoublequoteopen}{\isacharparenleft}bitU{\isacharparenright}list\ {\isasymRightarrow}\ int\ {\isasymRightarrow}{\isacharparenleft}{\isacharparenleft}bitU{\isacharparenright}list{\isacharparenright}option\ {\isachardoublequoteclose}\ \ \isakeyword{where}\ \isanewline
+\ \ \ \ \ {\isachardoublequoteopen}\ mod{\isacharunderscore}vec{\isacharunderscore}int{\isacharunderscore}maybe\ \ l\ r\ {\isacharequal}\ {\isacharparenleft}\ mod{\isacharunderscore}bv{\isacharunderscore}int\ \isanewline
+\ \ {\isacharparenleft}instance{\isacharunderscore}Sail{\isadigit{2}}{\isacharunderscore}values{\isacharunderscore}Bitvector{\isacharunderscore}list{\isacharunderscore}dict\isanewline
+\ \ \ \ \ instance{\isacharunderscore}Sail{\isadigit{2}}{\isacharunderscore}values{\isacharunderscore}BitU{\isacharunderscore}Sail{\isadigit{2}}{\isacharunderscore}values{\isacharunderscore}bitU{\isacharunderscore}dict{\isacharparenright}\ {\isacharparenleft}instance{\isacharunderscore}Sail{\isadigit{2}}{\isacharunderscore}values{\isacharunderscore}Bitvector{\isacharunderscore}list{\isacharunderscore}dict\isanewline
+\ \ \ instance{\isacharunderscore}Sail{\isadigit{2}}{\isacharunderscore}values{\isacharunderscore}BitU{\isacharunderscore}Sail{\isadigit{2}}{\isacharunderscore}values{\isacharunderscore}bitU{\isacharunderscore}dict{\isacharparenright}\ l\ r\ {\isacharparenright}{\isachardoublequoteclose}\isanewline
+\isanewline
+\isacommand{definition}\isamarkupfalse%
+\ mod{\isacharunderscore}vec{\isacharunderscore}int{\isacharunderscore}fail\ \ {\isacharcolon}{\isacharcolon}\ {\isachardoublequoteopen}{\isacharparenleft}bitU{\isacharparenright}list\ {\isasymRightarrow}\ int\ {\isasymRightarrow}{\isacharparenleft}{\isacharprime}rv{\isacharcomma}{\isacharparenleft}{\isacharparenleft}bitU{\isacharparenright}list{\isacharparenright}{\isacharcomma}{\isacharprime}e{\isacharparenright}monad\ {\isachardoublequoteclose}\ \ \isakeyword{where}\ \isanewline
+\ \ \ \ \ {\isachardoublequoteopen}\ mod{\isacharunderscore}vec{\isacharunderscore}int{\isacharunderscore}fail\ \ \ l\ r\ {\isacharequal}\ {\isacharparenleft}\ maybe{\isacharunderscore}fail\ {\isacharparenleft}{\isacharprime}{\isacharprime}mod{\isacharunderscore}vec{\isacharunderscore}int{\isacharprime}{\isacharprime}{\isacharparenright}\ {\isacharparenleft}mod{\isacharunderscore}bv{\isacharunderscore}int\ \isanewline
+\ \ {\isacharparenleft}instance{\isacharunderscore}Sail{\isadigit{2}}{\isacharunderscore}values{\isacharunderscore}Bitvector{\isacharunderscore}list{\isacharunderscore}dict\isanewline
+\ \ \ \ \ instance{\isacharunderscore}Sail{\isadigit{2}}{\isacharunderscore}values{\isacharunderscore}BitU{\isacharunderscore}Sail{\isadigit{2}}{\isacharunderscore}values{\isacharunderscore}bitU{\isacharunderscore}dict{\isacharparenright}\ {\isacharparenleft}instance{\isacharunderscore}Sail{\isadigit{2}}{\isacharunderscore}values{\isacharunderscore}Bitvector{\isacharunderscore}list{\isacharunderscore}dict\isanewline
+\ \ \ instance{\isacharunderscore}Sail{\isadigit{2}}{\isacharunderscore}values{\isacharunderscore}BitU{\isacharunderscore}Sail{\isadigit{2}}{\isacharunderscore}values{\isacharunderscore}bitU{\isacharunderscore}dict{\isacharparenright}\ l\ r{\isacharparenright}{\isacharparenright}{\isachardoublequoteclose}\isanewline
+\isanewline
+\isacommand{definition}\isamarkupfalse%
+\ mod{\isacharunderscore}vec{\isacharunderscore}int{\isacharunderscore}nondet\ \ {\isacharcolon}{\isacharcolon}\ {\isachardoublequoteopen}{\isacharparenleft}bitU{\isacharparenright}list\ {\isasymRightarrow}\ int\ {\isasymRightarrow}{\isacharparenleft}{\isacharprime}rv{\isacharcomma}{\isacharparenleft}{\isacharparenleft}bitU{\isacharparenright}list{\isacharparenright}{\isacharcomma}{\isacharprime}e{\isacharparenright}monad\ {\isachardoublequoteclose}\ \ \isakeyword{where}\ \isanewline
+\ \ \ \ \ {\isachardoublequoteopen}\ mod{\isacharunderscore}vec{\isacharunderscore}int{\isacharunderscore}nondet\ l\ r\ {\isacharequal}\ {\isacharparenleft}\ of{\isacharunderscore}bits{\isacharunderscore}nondet\ \isanewline
+\ \ {\isacharparenleft}instance{\isacharunderscore}Sail{\isadigit{2}}{\isacharunderscore}values{\isacharunderscore}Bitvector{\isacharunderscore}list{\isacharunderscore}dict\isanewline
+\ \ \ \ \ instance{\isacharunderscore}Sail{\isadigit{2}}{\isacharunderscore}values{\isacharunderscore}BitU{\isacharunderscore}Sail{\isadigit{2}}{\isacharunderscore}values{\isacharunderscore}bitU{\isacharunderscore}dict{\isacharparenright}\ {\isacharparenleft}mod{\isacharunderscore}vec{\isacharunderscore}int\ l\ r{\isacharparenright}{\isacharparenright}{\isachardoublequoteclose}\isanewline
+\isanewline
+\isanewline
+%
+\isamarkupcmt{\isa{val\ quot{\isacharunderscore}vec{\isacharunderscore}int\ \ \ \ \ \ \ \ {\isacharcolon}\ list\ bitU\ {\isacharminus}{\isachargreater}\ integer\ {\isacharminus}{\isachargreater}\ list\ bitU}%
+}\isanewline
+%
+\isamarkupcmt{\isa{val\ quot{\isacharunderscore}vec{\isacharunderscore}int{\isacharunderscore}maybe\ \ {\isacharcolon}\ list\ bitU\ {\isacharminus}{\isachargreater}\ integer\ {\isacharminus}{\isachargreater}\ maybe\ {\isacharparenleft}list\ bitU{\isacharparenright}}%
+}\isanewline
+%
+\isamarkupcmt{\isa{val\ quot{\isacharunderscore}vec{\isacharunderscore}int{\isacharunderscore}fail\ \ \ {\isacharcolon}\ forall\ {\isacharprime}rv\ {\isacharprime}e{\isachardot}\ list\ bitU\ {\isacharminus}{\isachargreater}\ integer\ {\isacharminus}{\isachargreater}\ monad\ {\isacharprime}rv\ {\isacharparenleft}list\ bitU{\isacharparenright}\ {\isacharprime}e}%
+}\isanewline
+%
+\isamarkupcmt{\isa{val\ quot{\isacharunderscore}vec{\isacharunderscore}int{\isacharunderscore}nondet\ {\isacharcolon}\ forall\ {\isacharprime}rv\ {\isacharprime}e{\isachardot}\ list\ bitU\ {\isacharminus}{\isachargreater}\ integer\ {\isacharminus}{\isachargreater}\ monad\ {\isacharprime}rv\ {\isacharparenleft}list\ bitU{\isacharparenright}\ {\isacharprime}e}%
+}\isanewline
+\isacommand{definition}\isamarkupfalse%
+\ quot{\isacharunderscore}vec{\isacharunderscore}int\ \ {\isacharcolon}{\isacharcolon}\ {\isachardoublequoteopen}{\isacharparenleft}bitU{\isacharparenright}list\ {\isasymRightarrow}\ int\ {\isasymRightarrow}{\isacharparenleft}bitU{\isacharparenright}list\ {\isachardoublequoteclose}\ \ \isakeyword{where}\ \isanewline
+\ \ \ \ \ {\isachardoublequoteopen}\ quot{\isacharunderscore}vec{\isacharunderscore}int\ \ \ \ \ \ \ \ l\ r\ {\isacharequal}\ {\isacharparenleft}\ case{\isacharunderscore}option\ {\isacharparenleft}repeat\ {\isacharbrackleft}BU{\isacharbrackright}\ {\isacharparenleft}int\ {\isacharparenleft}List{\isachardot}length\ l{\isacharparenright}{\isacharparenright}{\isacharparenright}\ id\ {\isacharparenleft}quot{\isacharunderscore}bv{\isacharunderscore}int\ \isanewline
+\ \ {\isacharparenleft}instance{\isacharunderscore}Sail{\isadigit{2}}{\isacharunderscore}values{\isacharunderscore}Bitvector{\isacharunderscore}list{\isacharunderscore}dict\isanewline
+\ \ \ \ \ instance{\isacharunderscore}Sail{\isadigit{2}}{\isacharunderscore}values{\isacharunderscore}BitU{\isacharunderscore}Sail{\isadigit{2}}{\isacharunderscore}values{\isacharunderscore}bitU{\isacharunderscore}dict{\isacharparenright}\ {\isacharparenleft}instance{\isacharunderscore}Sail{\isadigit{2}}{\isacharunderscore}values{\isacharunderscore}Bitvector{\isacharunderscore}list{\isacharunderscore}dict\isanewline
+\ \ \ instance{\isacharunderscore}Sail{\isadigit{2}}{\isacharunderscore}values{\isacharunderscore}BitU{\isacharunderscore}Sail{\isadigit{2}}{\isacharunderscore}values{\isacharunderscore}bitU{\isacharunderscore}dict{\isacharparenright}\ l\ r{\isacharparenright}{\isacharparenright}{\isachardoublequoteclose}\isanewline
+\isanewline
+\isacommand{definition}\isamarkupfalse%
+\ quot{\isacharunderscore}vec{\isacharunderscore}int{\isacharunderscore}maybe\ \ {\isacharcolon}{\isacharcolon}\ {\isachardoublequoteopen}{\isacharparenleft}bitU{\isacharparenright}list\ {\isasymRightarrow}\ int\ {\isasymRightarrow}{\isacharparenleft}{\isacharparenleft}bitU{\isacharparenright}list{\isacharparenright}option\ {\isachardoublequoteclose}\ \ \isakeyword{where}\ \isanewline
+\ \ \ \ \ {\isachardoublequoteopen}\ quot{\isacharunderscore}vec{\isacharunderscore}int{\isacharunderscore}maybe\ \ l\ r\ {\isacharequal}\ {\isacharparenleft}\ quot{\isacharunderscore}bv{\isacharunderscore}int\ \isanewline
+\ \ {\isacharparenleft}instance{\isacharunderscore}Sail{\isadigit{2}}{\isacharunderscore}values{\isacharunderscore}Bitvector{\isacharunderscore}list{\isacharunderscore}dict\isanewline
+\ \ \ \ \ instance{\isacharunderscore}Sail{\isadigit{2}}{\isacharunderscore}values{\isacharunderscore}BitU{\isacharunderscore}Sail{\isadigit{2}}{\isacharunderscore}values{\isacharunderscore}bitU{\isacharunderscore}dict{\isacharparenright}\ {\isacharparenleft}instance{\isacharunderscore}Sail{\isadigit{2}}{\isacharunderscore}values{\isacharunderscore}Bitvector{\isacharunderscore}list{\isacharunderscore}dict\isanewline
+\ \ \ instance{\isacharunderscore}Sail{\isadigit{2}}{\isacharunderscore}values{\isacharunderscore}BitU{\isacharunderscore}Sail{\isadigit{2}}{\isacharunderscore}values{\isacharunderscore}bitU{\isacharunderscore}dict{\isacharparenright}\ l\ r\ {\isacharparenright}{\isachardoublequoteclose}\isanewline
+\isanewline
+\isacommand{definition}\isamarkupfalse%
+\ quot{\isacharunderscore}vec{\isacharunderscore}int{\isacharunderscore}fail\ \ {\isacharcolon}{\isacharcolon}\ {\isachardoublequoteopen}{\isacharparenleft}bitU{\isacharparenright}list\ {\isasymRightarrow}\ int\ {\isasymRightarrow}{\isacharparenleft}{\isacharprime}rv{\isacharcomma}{\isacharparenleft}{\isacharparenleft}bitU{\isacharparenright}list{\isacharparenright}{\isacharcomma}{\isacharprime}e{\isacharparenright}monad\ {\isachardoublequoteclose}\ \ \isakeyword{where}\ \isanewline
+\ \ \ \ \ {\isachardoublequoteopen}\ quot{\isacharunderscore}vec{\isacharunderscore}int{\isacharunderscore}fail\ \ \ l\ r\ {\isacharequal}\ {\isacharparenleft}\ maybe{\isacharunderscore}fail\ {\isacharparenleft}{\isacharprime}{\isacharprime}quot{\isacharunderscore}vec{\isacharunderscore}int{\isacharprime}{\isacharprime}{\isacharparenright}\ {\isacharparenleft}quot{\isacharunderscore}bv{\isacharunderscore}int\ \isanewline
+\ \ {\isacharparenleft}instance{\isacharunderscore}Sail{\isadigit{2}}{\isacharunderscore}values{\isacharunderscore}Bitvector{\isacharunderscore}list{\isacharunderscore}dict\isanewline
+\ \ \ \ \ instance{\isacharunderscore}Sail{\isadigit{2}}{\isacharunderscore}values{\isacharunderscore}BitU{\isacharunderscore}Sail{\isadigit{2}}{\isacharunderscore}values{\isacharunderscore}bitU{\isacharunderscore}dict{\isacharparenright}\ {\isacharparenleft}instance{\isacharunderscore}Sail{\isadigit{2}}{\isacharunderscore}values{\isacharunderscore}Bitvector{\isacharunderscore}list{\isacharunderscore}dict\isanewline
+\ \ \ instance{\isacharunderscore}Sail{\isadigit{2}}{\isacharunderscore}values{\isacharunderscore}BitU{\isacharunderscore}Sail{\isadigit{2}}{\isacharunderscore}values{\isacharunderscore}bitU{\isacharunderscore}dict{\isacharparenright}\ l\ r{\isacharparenright}{\isacharparenright}{\isachardoublequoteclose}\isanewline
+\isanewline
+\isacommand{definition}\isamarkupfalse%
+\ quot{\isacharunderscore}vec{\isacharunderscore}int{\isacharunderscore}nondet\ \ {\isacharcolon}{\isacharcolon}\ {\isachardoublequoteopen}{\isacharparenleft}bitU{\isacharparenright}list\ {\isasymRightarrow}\ int\ {\isasymRightarrow}{\isacharparenleft}{\isacharprime}rv{\isacharcomma}{\isacharparenleft}{\isacharparenleft}bitU{\isacharparenright}list{\isacharparenright}{\isacharcomma}{\isacharprime}e{\isacharparenright}monad\ {\isachardoublequoteclose}\ \ \isakeyword{where}\ \isanewline
+\ \ \ \ \ {\isachardoublequoteopen}\ quot{\isacharunderscore}vec{\isacharunderscore}int{\isacharunderscore}nondet\ l\ r\ {\isacharequal}\ {\isacharparenleft}\ of{\isacharunderscore}bits{\isacharunderscore}nondet\ \isanewline
+\ \ {\isacharparenleft}instance{\isacharunderscore}Sail{\isadigit{2}}{\isacharunderscore}values{\isacharunderscore}Bitvector{\isacharunderscore}list{\isacharunderscore}dict\isanewline
+\ \ \ \ \ instance{\isacharunderscore}Sail{\isadigit{2}}{\isacharunderscore}values{\isacharunderscore}BitU{\isacharunderscore}Sail{\isadigit{2}}{\isacharunderscore}values{\isacharunderscore}bitU{\isacharunderscore}dict{\isacharparenright}\ {\isacharparenleft}quot{\isacharunderscore}vec{\isacharunderscore}int\ l\ r{\isacharparenright}{\isacharparenright}{\isachardoublequoteclose}\isanewline
+\isanewline
+\isanewline
+%
+\isamarkupcmt{\isa{val\ replicate{\isacharunderscore}bits\ {\isacharcolon}\ list\ bitU\ {\isacharminus}{\isachargreater}\ integer\ {\isacharminus}{\isachargreater}\ list\ bitU}%
+}\isanewline
+\isacommand{definition}\isamarkupfalse%
+\ replicate{\isacharunderscore}bits\ \ {\isacharcolon}{\isacharcolon}\ {\isachardoublequoteopen}{\isacharparenleft}bitU{\isacharparenright}list\ {\isasymRightarrow}\ int\ {\isasymRightarrow}{\isacharparenleft}bitU{\isacharparenright}list\ {\isachardoublequoteclose}\ \ \isakeyword{where}\ \isanewline
+\ \ \ \ \ {\isachardoublequoteopen}\ replicate{\isacharunderscore}bits\ {\isacharequal}\ {\isacharparenleft}\ \isanewline
+\ \ replicate{\isacharunderscore}bits{\isacharunderscore}bv\isanewline
+\ \ \ \ {\isacharparenleft}instance{\isacharunderscore}Sail{\isadigit{2}}{\isacharunderscore}values{\isacharunderscore}Bitvector{\isacharunderscore}list{\isacharunderscore}dict\isanewline
+\ \ \ \ \ \ \ instance{\isacharunderscore}Sail{\isadigit{2}}{\isacharunderscore}values{\isacharunderscore}BitU{\isacharunderscore}Sail{\isadigit{2}}{\isacharunderscore}values{\isacharunderscore}bitU{\isacharunderscore}dict{\isacharparenright}\ {\isacharparenright}{\isachardoublequoteclose}\isanewline
+\isanewline
+\isanewline
+%
+\isamarkupcmt{\isa{val\ duplicate\ {\isacharcolon}\ bitU\ {\isacharminus}{\isachargreater}\ integer\ {\isacharminus}{\isachargreater}\ list\ bitU}%
+}\isanewline
+\isacommand{definition}\isamarkupfalse%
+\ duplicate\ \ {\isacharcolon}{\isacharcolon}\ {\isachardoublequoteopen}\ bitU\ {\isasymRightarrow}\ int\ {\isasymRightarrow}{\isacharparenleft}bitU{\isacharparenright}list\ {\isachardoublequoteclose}\ \ \isakeyword{where}\ \isanewline
+\ \ \ \ \ {\isachardoublequoteopen}\ duplicate\ {\isacharequal}\ {\isacharparenleft}\ \isanewline
+\ \ duplicate{\isacharunderscore}bit{\isacharunderscore}bv\ instance{\isacharunderscore}Sail{\isadigit{2}}{\isacharunderscore}values{\isacharunderscore}BitU{\isacharunderscore}Sail{\isadigit{2}}{\isacharunderscore}values{\isacharunderscore}bitU{\isacharunderscore}dict\ {\isacharparenright}{\isachardoublequoteclose}\isanewline
+\isanewline
+\isacommand{definition}\isamarkupfalse%
+\ duplicate{\isacharunderscore}maybe\ \ {\isacharcolon}{\isacharcolon}\ {\isachardoublequoteopen}\ bitU\ {\isasymRightarrow}\ int\ {\isasymRightarrow}{\isacharparenleft}{\isacharparenleft}bitU{\isacharparenright}list{\isacharparenright}option\ {\isachardoublequoteclose}\ \ \isakeyword{where}\ \isanewline
+\ \ \ \ \ {\isachardoublequoteopen}\ duplicate{\isacharunderscore}maybe\ b\ n\ {\isacharequal}\ {\isacharparenleft}\ Some\ {\isacharparenleft}duplicate\ b\ n{\isacharparenright}{\isacharparenright}{\isachardoublequoteclose}\isanewline
+\isanewline
+\isacommand{definition}\isamarkupfalse%
+\ duplicate{\isacharunderscore}fail\ \ {\isacharcolon}{\isacharcolon}\ {\isachardoublequoteopen}\ bitU\ {\isasymRightarrow}\ int\ {\isasymRightarrow}{\isacharparenleft}{\isacharprime}b{\isacharcomma}{\isacharparenleft}{\isacharparenleft}bitU{\isacharparenright}list{\isacharparenright}{\isacharcomma}{\isacharprime}a{\isacharparenright}monad\ {\isachardoublequoteclose}\ \ \isakeyword{where}\ \isanewline
+\ \ \ \ \ {\isachardoublequoteopen}\ duplicate{\isacharunderscore}fail\ b\ n\ {\isacharequal}\ {\isacharparenleft}\ return\ {\isacharparenleft}duplicate\ b\ n{\isacharparenright}{\isacharparenright}{\isachardoublequoteclose}\isanewline
+\isanewline
+\isacommand{definition}\isamarkupfalse%
+\ duplicate{\isacharunderscore}nondet\ \ {\isacharcolon}{\isacharcolon}\ {\isachardoublequoteopen}\ bitU\ {\isasymRightarrow}\ int\ {\isasymRightarrow}{\isacharparenleft}{\isacharprime}b{\isacharcomma}{\isacharparenleft}{\isacharparenleft}bitU{\isacharparenright}list{\isacharparenright}{\isacharcomma}{\isacharprime}a{\isacharparenright}monad\ {\isachardoublequoteclose}\ \ \isakeyword{where}\ \isanewline
+\ \ \ \ \ {\isachardoublequoteopen}\ duplicate{\isacharunderscore}nondet\ b\ n\ {\isacharequal}\ {\isacharparenleft}\isanewline
+\ \ bool{\isacharunderscore}of{\isacharunderscore}bitU{\isacharunderscore}nondet\ b\ {\isasymbind}\ {\isacharparenleft}{\isasymlambda}\ b\ {\isachardot}\ \isanewline
+\ \ return\ {\isacharparenleft}duplicate\ {\isacharparenleft}bitU{\isacharunderscore}of{\isacharunderscore}bool\ b{\isacharparenright}\ n{\isacharparenright}{\isacharparenright}{\isacharparenright}{\isachardoublequoteclose}\isanewline
+\isanewline
+\isanewline
+%
+\isamarkupcmt{\isa{val\ reverse{\isacharunderscore}endianness\ {\isacharcolon}\ list\ bitU\ {\isacharminus}{\isachargreater}\ list\ bitU}%
+}\isanewline
+\isacommand{definition}\isamarkupfalse%
+\ reverse{\isacharunderscore}endianness\ \ {\isacharcolon}{\isacharcolon}\ {\isachardoublequoteopen}{\isacharparenleft}bitU{\isacharparenright}list\ {\isasymRightarrow}{\isacharparenleft}bitU{\isacharparenright}list\ {\isachardoublequoteclose}\ \ \isakeyword{where}\ \isanewline
+\ \ \ \ \ {\isachardoublequoteopen}\ reverse{\isacharunderscore}endianness\ v\ {\isacharequal}\ {\isacharparenleft}\ reverse{\isacharunderscore}endianness{\isacharunderscore}list\ v\ {\isacharparenright}{\isachardoublequoteclose}\isanewline
+\isanewline
+\isanewline
+%
+\isamarkupcmt{\isa{val\ get{\isacharunderscore}slice{\isacharunderscore}int\ {\isacharcolon}\ integer\ {\isacharminus}{\isachargreater}\ integer\ {\isacharminus}{\isachargreater}\ integer\ {\isacharminus}{\isachargreater}\ list\ bitU}%
+}\isanewline
+\isacommand{definition}\isamarkupfalse%
+\ get{\isacharunderscore}slice{\isacharunderscore}int\ \ {\isacharcolon}{\isacharcolon}\ {\isachardoublequoteopen}\ int\ {\isasymRightarrow}\ int\ {\isasymRightarrow}\ int\ {\isasymRightarrow}{\isacharparenleft}bitU{\isacharparenright}list\ {\isachardoublequoteclose}\ \ \isakeyword{where}\ \isanewline
+\ \ \ \ \ {\isachardoublequoteopen}\ get{\isacharunderscore}slice{\isacharunderscore}int\ {\isacharequal}\ {\isacharparenleft}\ \isanewline
+\ \ get{\isacharunderscore}slice{\isacharunderscore}int{\isacharunderscore}bv\isanewline
+\ \ \ \ {\isacharparenleft}instance{\isacharunderscore}Sail{\isadigit{2}}{\isacharunderscore}values{\isacharunderscore}Bitvector{\isacharunderscore}list{\isacharunderscore}dict\isanewline
+\ \ \ \ \ \ \ instance{\isacharunderscore}Sail{\isadigit{2}}{\isacharunderscore}values{\isacharunderscore}BitU{\isacharunderscore}Sail{\isadigit{2}}{\isacharunderscore}values{\isacharunderscore}bitU{\isacharunderscore}dict{\isacharparenright}\ {\isacharparenright}{\isachardoublequoteclose}\isanewline
+\isanewline
+\isanewline
+%
+\isamarkupcmt{\isa{val\ set{\isacharunderscore}slice{\isacharunderscore}int\ {\isacharcolon}\ integer\ {\isacharminus}{\isachargreater}\ integer\ {\isacharminus}{\isachargreater}\ integer\ {\isacharminus}{\isachargreater}\ list\ bitU\ {\isacharminus}{\isachargreater}\ integer}%
+}\isanewline
+\isacommand{definition}\isamarkupfalse%
+\ set{\isacharunderscore}slice{\isacharunderscore}int\ \ {\isacharcolon}{\isacharcolon}\ {\isachardoublequoteopen}\ int\ {\isasymRightarrow}\ int\ {\isasymRightarrow}\ int\ {\isasymRightarrow}{\isacharparenleft}bitU{\isacharparenright}list\ {\isasymRightarrow}\ int\ {\isachardoublequoteclose}\ \ \isakeyword{where}\ \isanewline
+\ \ \ \ \ {\isachardoublequoteopen}\ set{\isacharunderscore}slice{\isacharunderscore}int\ {\isacharequal}\ {\isacharparenleft}\ \isanewline
+\ \ set{\isacharunderscore}slice{\isacharunderscore}int{\isacharunderscore}bv\isanewline
+\ \ \ \ {\isacharparenleft}instance{\isacharunderscore}Sail{\isadigit{2}}{\isacharunderscore}values{\isacharunderscore}Bitvector{\isacharunderscore}list{\isacharunderscore}dict\isanewline
+\ \ \ \ \ \ \ instance{\isacharunderscore}Sail{\isadigit{2}}{\isacharunderscore}values{\isacharunderscore}BitU{\isacharunderscore}Sail{\isadigit{2}}{\isacharunderscore}values{\isacharunderscore}bitU{\isacharunderscore}dict{\isacharparenright}\ {\isacharparenright}{\isachardoublequoteclose}\isanewline
+\isanewline
+\isanewline
+%
+\isamarkupcmt{\isa{val\ slice\ {\isacharcolon}\ list\ bitU\ {\isacharminus}{\isachargreater}\ integer\ {\isacharminus}{\isachargreater}\ integer\ {\isacharminus}{\isachargreater}\ list\ bitU}%
+}\isanewline
+\isacommand{definition}\isamarkupfalse%
+\ slice\ \ {\isacharcolon}{\isacharcolon}\ {\isachardoublequoteopen}{\isacharparenleft}bitU{\isacharparenright}list\ {\isasymRightarrow}\ int\ {\isasymRightarrow}\ int\ {\isasymRightarrow}{\isacharparenleft}bitU{\isacharparenright}list\ {\isachardoublequoteclose}\ \ \isakeyword{where}\ \isanewline
+\ \ \ \ \ {\isachardoublequoteopen}\ slice\ v\ lo\ len\ {\isacharequal}\ {\isacharparenleft}\isanewline
+\ \ subrange{\isacharunderscore}vec{\isacharunderscore}dec\ v\ {\isacharparenleft}{\isacharparenleft}lo\ {\isacharplus}\ len{\isacharparenright}\ {\isacharminus}{\isacharparenleft}\ {\isadigit{1}}\ {\isacharcolon}{\isacharcolon}\ int{\isacharparenright}{\isacharparenright}\ lo\ {\isacharparenright}{\isachardoublequoteclose}\isanewline
+\isanewline
+\isanewline
+%
+\isamarkupcmt{\isa{val\ set{\isacharunderscore}slice\ {\isacharcolon}\ integer\ {\isacharminus}{\isachargreater}\ integer\ {\isacharminus}{\isachargreater}\ list\ bitU\ {\isacharminus}{\isachargreater}\ integer\ {\isacharminus}{\isachargreater}\ list\ bitU\ {\isacharminus}{\isachargreater}\ list\ bitU}%
+}\isanewline
+\isacommand{definition}\isamarkupfalse%
+\ set{\isacharunderscore}slice\ \ {\isacharcolon}{\isacharcolon}\ {\isachardoublequoteopen}\ int\ {\isasymRightarrow}\ int\ {\isasymRightarrow}{\isacharparenleft}bitU{\isacharparenright}list\ {\isasymRightarrow}\ int\ {\isasymRightarrow}{\isacharparenleft}bitU{\isacharparenright}list\ {\isasymRightarrow}{\isacharparenleft}bitU{\isacharparenright}list\ {\isachardoublequoteclose}\ \ \isakeyword{where}\ \isanewline
+\ \ \ \ \ {\isachardoublequoteopen}\ set{\isacharunderscore}slice\ {\isacharparenleft}out{\isacharunderscore}len{\isacharcolon}{\isacharcolon}ii{\isacharparenright}\ {\isacharparenleft}slice{\isacharunderscore}len{\isacharcolon}{\isacharcolon}ii{\isacharparenright}\ out\ {\isacharparenleft}n{\isacharcolon}{\isacharcolon}ii{\isacharparenright}\ v\ {\isacharequal}\ {\isacharparenleft}\isanewline
+\ \ update{\isacharunderscore}subrange{\isacharunderscore}vec{\isacharunderscore}dec\ out\ {\isacharparenleft}{\isacharparenleft}n\ {\isacharplus}\ slice{\isacharunderscore}len{\isacharparenright}\ {\isacharminus}{\isacharparenleft}\ {\isadigit{1}}\ {\isacharcolon}{\isacharcolon}\ int{\isacharparenright}{\isacharparenright}\ n\ v\ {\isacharparenright}{\isachardoublequoteclose}\isanewline
+\isanewline
+\isanewline
+%
+\isamarkupcmt{\isa{val\ eq{\isacharunderscore}vec\ \ \ \ {\isacharcolon}\ list\ bitU\ {\isacharminus}{\isachargreater}\ list\ bitU\ {\isacharminus}{\isachargreater}\ bool}%
+}\isanewline
+%
+\isamarkupcmt{\isa{val\ neq{\isacharunderscore}vec\ \ \ {\isacharcolon}\ list\ bitU\ {\isacharminus}{\isachargreater}\ list\ bitU\ {\isacharminus}{\isachargreater}\ bool}%
+}\isanewline
+\isacommand{definition}\isamarkupfalse%
+\ eq{\isacharunderscore}vec\ \ {\isacharcolon}{\isacharcolon}\ {\isachardoublequoteopen}{\isacharparenleft}bitU{\isacharparenright}list\ {\isasymRightarrow}{\isacharparenleft}bitU{\isacharparenright}list\ {\isasymRightarrow}\ bool\ {\isachardoublequoteclose}\ \ \ \ \ \isakeyword{where}\ \isanewline
+\ \ \ \ \ {\isachardoublequoteopen}\ eq{\isacharunderscore}vec\ \ \ \ {\isacharequal}\ {\isacharparenleft}\ \isanewline
+\ \ eq{\isacharunderscore}bv\isanewline
+\ \ \ \ {\isacharparenleft}instance{\isacharunderscore}Sail{\isadigit{2}}{\isacharunderscore}values{\isacharunderscore}Bitvector{\isacharunderscore}list{\isacharunderscore}dict\isanewline
+\ \ \ \ \ \ \ instance{\isacharunderscore}Sail{\isadigit{2}}{\isacharunderscore}values{\isacharunderscore}BitU{\isacharunderscore}Sail{\isadigit{2}}{\isacharunderscore}values{\isacharunderscore}bitU{\isacharunderscore}dict{\isacharparenright}\ {\isacharparenright}{\isachardoublequoteclose}\isanewline
+\isanewline
+\isacommand{definition}\isamarkupfalse%
+\ neq{\isacharunderscore}vec\ \ {\isacharcolon}{\isacharcolon}\ {\isachardoublequoteopen}{\isacharparenleft}bitU{\isacharparenright}list\ {\isasymRightarrow}{\isacharparenleft}bitU{\isacharparenright}list\ {\isasymRightarrow}\ bool\ {\isachardoublequoteclose}\ \ \ \ \isakeyword{where}\ \isanewline
+\ \ \ \ \ {\isachardoublequoteopen}\ neq{\isacharunderscore}vec\ \ \ {\isacharequal}\ {\isacharparenleft}\ \isanewline
+\ \ neq{\isacharunderscore}bv\isanewline
+\ \ \ \ {\isacharparenleft}instance{\isacharunderscore}Sail{\isadigit{2}}{\isacharunderscore}values{\isacharunderscore}Bitvector{\isacharunderscore}list{\isacharunderscore}dict\isanewline
+\ \ \ \ \ \ \ instance{\isacharunderscore}Sail{\isadigit{2}}{\isacharunderscore}values{\isacharunderscore}BitU{\isacharunderscore}Sail{\isadigit{2}}{\isacharunderscore}values{\isacharunderscore}bitU{\isacharunderscore}dict{\isacharparenright}\ {\isacharparenright}{\isachardoublequoteclose}\isanewline
+%
+\isadelimtheory
+\isanewline
+%
+\endisadelimtheory
+%
+\isatagtheory
+\isacommand{end}\isamarkupfalse%
+%
+\endisatagtheory
+{\isafoldtheory}%
+%
+\isadelimtheory
+%
+\endisadelimtheory
+%
+\end{isabellebody}%
+\endinput
+%:%file=~/workspace/uni/rems/github/sail/lib/isabelle/Sail2_operators_bitlists.thy%:%
+%:%11=1%:%
+%:%27=3%:%
+%:%28=3%:%
+%:%29=4%:%
+%:%30=5%:%
+%:%31=6%:%
+%:%32=7%:%
+%:%33=8%:%
+%:%34=9%:%
+%:%35=10%:%
+%:%36=11%:%
+%:%37=12%:%
+%:%38=13%:%
+%:%39=14%:%
+%:%40=15%:%
+%:%43=16%:%
+%:%46=17%:%
+%:%49=18%:%
+%:%52=19%:%
+%:%55=20%:%
+%:%58=21%:%
+%:%59=22%:%
+%:%62=23%:%
+%:%63=24%:%
+%:%71=25%:%
+%:%74=26%:%
+%:%75=26%:%
+%:%76=27%:%
+%:%77=28%:%
+%:%78=29%:%
+%:%79=29%:%
+%:%80=30%:%
+%:%81=31%:%
+%:%82=32%:%
+%:%83=33%:%
+%:%84=33%:%
+%:%85=34%:%
+%:%87=36%:%
+%:%88=37%:%
+%:%89=38%:%
+%:%90=38%:%
+%:%91=39%:%
+%:%92=40%:%
+%:%93=41%:%
+%:%96=42%:%
+%:%97=43%:%
+%:%98=43%:%
+%:%99=44%:%
+%:%100=45%:%
+%:%101=46%:%
+%:%102=46%:%
+%:%103=47%:%
+%:%104=48%:%
+%:%105=49%:%
+%:%106=50%:%
+%:%107=50%:%
+%:%108=51%:%
+%:%110=53%:%
+%:%111=54%:%
+%:%112=55%:%
+%:%113=55%:%
+%:%114=56%:%
+%:%115=57%:%
+%:%116=58%:%
+%:%119=59%:%
+%:%120=60%:%
+%:%121=60%:%
+%:%122=61%:%
+%:%125=64%:%
+%:%126=65%:%
+%:%127=66%:%
+%:%130=67%:%
+%:%131=68%:%
+%:%132=68%:%
+%:%133=69%:%
+%:%136=72%:%
+%:%137=73%:%
+%:%138=74%:%
+%:%141=75%:%
+%:%142=76%:%
+%:%143=76%:%
+%:%144=77%:%
+%:%145=78%:%
+%:%146=79%:%
+%:%149=80%:%
+%:%150=81%:%
+%:%151=81%:%
+%:%152=82%:%
+%:%153=83%:%
+%:%154=84%:%
+%:%157=85%:%
+%:%158=86%:%
+%:%159=86%:%
+%:%160=87%:%
+%:%161=88%:%
+%:%162=89%:%
+%:%165=90%:%
+%:%166=91%:%
+%:%167=91%:%
+%:%168=92%:%
+%:%170=94%:%
+%:%171=95%:%
+%:%172=96%:%
+%:%175=97%:%
+%:%178=98%:%
+%:%181=99%:%
+%:%184=100%:%
+%:%187=101%:%
+%:%188=102%:%
+%:%191=103%:%
+%:%192=104%:%
+%:%193=104%:%
+%:%194=105%:%
+%:%197=108%:%
+%:%198=109%:%
+%:%199=110%:%
+%:%202=111%:%
+%:%203=112%:%
+%:%204=112%:%
+%:%205=113%:%
+%:%208=116%:%
+%:%209=117%:%
+%:%210=118%:%
+%:%213=119%:%
+%:%214=120%:%
+%:%215=120%:%
+%:%216=121%:%
+%:%219=124%:%
+%:%220=125%:%
+%:%221=126%:%
+%:%222=126%:%
+%:%223=127%:%
+%:%224=128%:%
+%:%225=129%:%
+%:%226=129%:%
+%:%227=130%:%
+%:%228=131%:%
+%:%229=132%:%
+%:%230=132%:%
+%:%231=133%:%
+%:%232=134%:%
+%:%233=135%:%
+%:%236=136%:%
+%:%237=137%:%
+%:%238=137%:%
+%:%239=138%:%
+%:%242=141%:%
+%:%243=142%:%
+%:%244=143%:%
+%:%245=143%:%
+%:%246=144%:%
+%:%247=145%:%
+%:%248=146%:%
+%:%249=146%:%
+%:%250=147%:%
+%:%251=148%:%
+%:%252=149%:%
+%:%253=149%:%
+%:%254=150%:%
+%:%255=151%:%
+%:%256=152%:%
+%:%259=153%:%
+%:%260=154%:%
+%:%261=154%:%
+%:%262=155%:%
+%:%265=158%:%
+%:%266=159%:%
+%:%267=160%:%
+%:%270=161%:%
+%:%271=162%:%
+%:%272=162%:%
+%:%273=163%:%
+%:%276=166%:%
+%:%277=167%:%
+%:%278=168%:%
+%:%281=169%:%
+%:%282=170%:%
+%:%283=170%:%
+%:%284=171%:%
+%:%289=176%:%
+%:%290=177%:%
+%:%291=178%:%
+%:%294=179%:%
+%:%295=180%:%
+%:%296=180%:%
+%:%297=181%:%
+%:%302=186%:%
+%:%303=187%:%
+%:%304=188%:%
+%:%307=189%:%
+%:%308=190%:%
+%:%309=190%:%
+%:%310=191%:%
+%:%315=196%:%
+%:%316=197%:%
+%:%317=198%:%
+%:%320=199%:%
+%:%321=200%:%
+%:%322=200%:%
+%:%323=201%:%
+%:%326=204%:%
+%:%327=205%:%
+%:%328=206%:%
+%:%329=206%:%
+%:%330=207%:%
+%:%331=208%:%
+%:%332=209%:%
+%:%333=209%:%
+%:%334=210%:%
+%:%335=211%:%
+%:%336=212%:%
+%:%337=212%:%
+%:%338=213%:%
+%:%339=214%:%
+%:%340=215%:%
+%:%343=216%:%
+%:%344=217%:%
+%:%345=217%:%
+%:%346=218%:%
+%:%347=219%:%
+%:%348=220%:%
+%:%349=220%:%
+%:%350=221%:%
+%:%351=222%:%
+%:%352=223%:%
+%:%353=223%:%
+%:%354=224%:%
+%:%355=225%:%
+%:%356=226%:%
+%:%357=226%:%
+%:%358=227%:%
+%:%359=228%:%
+%:%360=229%:%
+%:%363=230%:%
+%:%364=231%:%
+%:%365=231%:%
+%:%366=232%:%
+%:%367=233%:%
+%:%368=234%:%
+%:%369=234%:%
+%:%370=235%:%
+%:%371=236%:%
+%:%372=237%:%
+%:%373=237%:%
+%:%374=238%:%
+%:%375=239%:%
+%:%376=240%:%
+%:%377=240%:%
+%:%378=241%:%
+%:%379=242%:%
+%:%380=243%:%
+%:%383=244%:%
+%:%384=245%:%
+%:%385=245%:%
+%:%386=246%:%
+%:%389=249%:%
+%:%390=250%:%
+%:%391=251%:%
+%:%394=252%:%
+%:%395=253%:%
+%:%396=253%:%
+%:%397=254%:%
+%:%400=257%:%
+%:%401=258%:%
+%:%402=259%:%
+%:%403=259%:%
+%:%404=260%:%
+%:%405=261%:%
+%:%406=262%:%
+%:%407=262%:%
+%:%408=263%:%
+%:%409=264%:%
+%:%410=265%:%
+%:%411=265%:%
+%:%412=266%:%
+%:%413=267%:%
+%:%414=268%:%
+%:%417=269%:%
+%:%418=270%:%
+%:%419=270%:%
+%:%420=271%:%
+%:%423=274%:%
+%:%424=275%:%
+%:%425=276%:%
+%:%428=277%:%
+%:%429=278%:%
+%:%430=278%:%
+%:%431=279%:%
+%:%434=282%:%
+%:%435=283%:%
+%:%436=284%:%
+%:%439=285%:%
+%:%442=286%:%
+%:%445=287%:%
+%:%448=288%:%
+%:%449=289%:%
+%:%450=289%:%
+%:%451=290%:%
+%:%452=291%:%
+%:%453=292%:%
+%:%454=292%:%
+%:%455=293%:%
+%:%456=294%:%
+%:%457=295%:%
+%:%458=295%:%
+%:%459=296%:%
+%:%460=297%:%
+%:%461=298%:%
+%:%462=298%:%
+%:%463=299%:%
+%:%464=300%:%
+%:%465=301%:%
+%:%468=303%:%
+%:%469=304%:%
+%:%470=304%:%
+%:%471=305%:%
+%:%478=312%:%
+%:%479=313%:%
+%:%480=314%:%
+%:%483=315%:%
+%:%486=316%:%
+%:%489=317%:%
+%:%492=318%:%
+%:%495=319%:%
+%:%498=320%:%
+%:%499=321%:%
+%:%500=321%:%
+%:%501=322%:%
+%:%502=323%:%
+%:%503=324%:%
+%:%504=324%:%
+%:%505=325%:%
+%:%506=326%:%
+%:%507=327%:%
+%:%508=327%:%
+%:%509=328%:%
+%:%510=329%:%
+%:%511=330%:%
+%:%512=330%:%
+%:%513=331%:%
+%:%514=332%:%
+%:%515=333%:%
+%:%516=333%:%
+%:%517=334%:%
+%:%519=336%:%
+%:%520=337%:%
+%:%521=338%:%
+%:%522=338%:%
+%:%523=339%:%
+%:%525=341%:%
+%:%526=342%:%
+%:%527=343%:%
+%:%530=344%:%
+%:%533=345%:%
+%:%536=346%:%
+%:%537=347%:%
+%:%538=347%:%
+%:%539=348%:%
+%:%541=350%:%
+%:%542=351%:%
+%:%543=352%:%
+%:%544=352%:%
+%:%545=353%:%
+%:%547=355%:%
+%:%548=356%:%
+%:%549=357%:%
+%:%550=357%:%
+%:%551=358%:%
+%:%553=360%:%
+%:%554=361%:%
+%:%555=362%:%
+%:%558=363%:%
+%:%561=364%:%
+%:%564=365%:%
+%:%565=366%:%
+%:%566=366%:%
+%:%567=367%:%
+%:%569=369%:%
+%:%570=370%:%
+%:%571=371%:%
+%:%572=371%:%
+%:%573=372%:%
+%:%575=374%:%
+%:%576=375%:%
+%:%577=376%:%
+%:%578=376%:%
+%:%579=377%:%
+%:%581=379%:%
+%:%582=380%:%
+%:%583=381%:%
+%:%586=382%:%
+%:%589=383%:%
+%:%592=384%:%
+%:%595=385%:%
+%:%596=386%:%
+%:%597=387%:%
+%:%598=387%:%
+%:%599=388%:%
+%:%600=389%:%
+%:%601=390%:%
+%:%602=391%:%
+%:%603=391%:%
+%:%604=392%:%
+%:%605=393%:%
+%:%606=394%:%
+%:%607=395%:%
+%:%608=395%:%
+%:%609=396%:%
+%:%610=397%:%
+%:%611=398%:%
+%:%612=399%:%
+%:%613=399%:%
+%:%614=400%:%
+%:%615=401%:%
+%:%616=402%:%
+%:%617=403%:%
+%:%618=403%:%
+%:%619=404%:%
+%:%621=406%:%
+%:%622=407%:%
+%:%623=408%:%
+%:%624=409%:%
+%:%625=409%:%
+%:%626=410%:%
+%:%627=411%:%
+%:%628=412%:%
+%:%629=413%:%
+%:%630=413%:%
+%:%631=414%:%
+%:%632=415%:%
+%:%633=416%:%
+%:%634=417%:%
+%:%635=417%:%
+%:%636=418%:%
+%:%637=419%:%
+%:%638=420%:%
+%:%639=421%:%
+%:%640=421%:%
+%:%641=422%:%
+%:%642=423%:%
+%:%643=424%:%
+%:%644=425%:%
+%:%645=425%:%
+%:%646=426%:%
+%:%648=428%:%
+%:%649=429%:%
+%:%650=430%:%
+%:%651=431%:%
+%:%652=431%:%
+%:%653=432%:%
+%:%654=433%:%
+%:%655=434%:%
+%:%656=435%:%
+%:%657=435%:%
+%:%658=436%:%
+%:%659=437%:%
+%:%660=438%:%
+%:%661=439%:%
+%:%662=439%:%
+%:%663=440%:%
+%:%664=441%:%
+%:%665=442%:%
+%:%666=443%:%
+%:%667=443%:%
+%:%668=444%:%
+%:%669=445%:%
+%:%670=446%:%
+%:%671=447%:%
+%:%672=447%:%
+%:%673=448%:%
+%:%675=450%:%
+%:%676=451%:%
+%:%677=452%:%
+%:%678=453%:%
+%:%679=453%:%
+%:%680=454%:%
+%:%681=455%:%
+%:%682=456%:%
+%:%683=457%:%
+%:%684=457%:%
+%:%685=458%:%
+%:%686=459%:%
+%:%687=460%:%
+%:%688=461%:%
+%:%689=461%:%
+%:%690=462%:%
+%:%691=463%:%
+%:%692=464%:%
+%:%693=465%:%
+%:%694=465%:%
+%:%695=466%:%
+%:%696=467%:%
+%:%697=468%:%
+%:%698=469%:%
+%:%699=469%:%
+%:%700=470%:%
+%:%702=472%:%
+%:%703=473%:%
+%:%704=474%:%
+%:%707=495%:%
+%:%708=496%:%
+%:%711=497%:%
+%:%714=498%:%
+%:%717=499%:%
+%:%720=500%:%
+%:%723=501%:%
+%:%724=502%:%
+%:%725=502%:%
+%:%726=503%:%
+%:%729=506%:%
+%:%730=507%:%
+%:%731=508%:%
+%:%732=508%:%
+%:%733=509%:%
+%:%736=512%:%
+%:%737=513%:%
+%:%738=514%:%
+%:%739=514%:%
+%:%740=515%:%
+%:%743=518%:%
+%:%744=519%:%
+%:%745=520%:%
+%:%746=520%:%
+%:%747=521%:%
+%:%750=524%:%
+%:%751=525%:%
+%:%752=526%:%
+%:%753=526%:%
+%:%754=527%:%
+%:%757=530%:%
+%:%758=531%:%
+%:%759=532%:%
+%:%762=533%:%
+%:%765=534%:%
+%:%768=535%:%
+%:%771=536%:%
+%:%772=537%:%
+%:%773=537%:%
+%:%774=538%:%
+%:%777=541%:%
+%:%778=542%:%
+%:%779=543%:%
+%:%780=543%:%
+%:%781=544%:%
+%:%784=547%:%
+%:%785=548%:%
+%:%786=549%:%
+%:%787=549%:%
+%:%788=550%:%
+%:%791=553%:%
+%:%792=554%:%
+%:%793=555%:%
+%:%794=555%:%
+%:%795=556%:%
+%:%797=558%:%
+%:%798=559%:%
+%:%799=560%:%
+%:%802=561%:%
+%:%805=562%:%
+%:%808=563%:%
+%:%811=564%:%
+%:%812=565%:%
+%:%813=565%:%
+%:%814=566%:%
+%:%817=569%:%
+%:%818=570%:%
+%:%819=571%:%
+%:%820=571%:%
+%:%821=572%:%
+%:%824=575%:%
+%:%825=576%:%
+%:%826=577%:%
+%:%827=577%:%
+%:%828=578%:%
+%:%831=581%:%
+%:%832=582%:%
+%:%833=583%:%
+%:%834=583%:%
+%:%835=584%:%
+%:%837=586%:%
+%:%838=587%:%
+%:%839=588%:%
+%:%842=589%:%
+%:%845=590%:%
+%:%848=591%:%
+%:%851=592%:%
+%:%852=593%:%
+%:%853=593%:%
+%:%854=594%:%
+%:%857=597%:%
+%:%858=598%:%
+%:%859=599%:%
+%:%860=599%:%
+%:%861=600%:%
+%:%864=603%:%
+%:%865=604%:%
+%:%866=605%:%
+%:%867=605%:%
+%:%868=606%:%
+%:%871=609%:%
+%:%872=610%:%
+%:%873=611%:%
+%:%874=611%:%
+%:%875=612%:%
+%:%877=614%:%
+%:%878=615%:%
+%:%879=616%:%
+%:%882=617%:%
+%:%885=618%:%
+%:%888=619%:%
+%:%891=620%:%
+%:%892=621%:%
+%:%893=621%:%
+%:%894=622%:%
+%:%897=625%:%
+%:%898=626%:%
+%:%899=627%:%
+%:%900=627%:%
+%:%901=628%:%
+%:%904=631%:%
+%:%905=632%:%
+%:%906=633%:%
+%:%907=633%:%
+%:%908=634%:%
+%:%911=637%:%
+%:%912=638%:%
+%:%913=639%:%
+%:%914=639%:%
+%:%915=640%:%
+%:%917=642%:%
+%:%918=643%:%
+%:%919=644%:%
+%:%922=645%:%
+%:%925=646%:%
+%:%928=647%:%
+%:%931=648%:%
+%:%932=649%:%
+%:%933=649%:%
+%:%934=650%:%
+%:%937=653%:%
+%:%938=654%:%
+%:%939=655%:%
+%:%940=655%:%
+%:%941=656%:%
+%:%944=659%:%
+%:%945=660%:%
+%:%946=661%:%
+%:%947=661%:%
+%:%948=662%:%
+%:%951=665%:%
+%:%952=666%:%
+%:%953=667%:%
+%:%954=667%:%
+%:%955=668%:%
+%:%957=670%:%
+%:%958=671%:%
+%:%959=672%:%
+%:%962=673%:%
+%:%963=674%:%
+%:%964=674%:%
+%:%965=675%:%
+%:%968=678%:%
+%:%969=679%:%
+%:%970=680%:%
+%:%973=681%:%
+%:%974=682%:%
+%:%975=682%:%
+%:%976=683%:%
+%:%977=684%:%
+%:%978=685%:%
+%:%979=686%:%
+%:%980=686%:%
+%:%981=687%:%
+%:%982=688%:%
+%:%983=689%:%
+%:%984=689%:%
+%:%985=690%:%
+%:%986=691%:%
+%:%987=692%:%
+%:%988=692%:%
+%:%989=693%:%
+%:%991=695%:%
+%:%992=696%:%
+%:%993=697%:%
+%:%996=698%:%
+%:%997=699%:%
+%:%998=699%:%
+%:%999=700%:%
+%:%1000=701%:%
+%:%1001=702%:%
+%:%1004=703%:%
+%:%1005=704%:%
+%:%1006=704%:%
+%:%1007=705%:%
+%:%1010=708%:%
+%:%1011=709%:%
+%:%1012=710%:%
+%:%1015=711%:%
+%:%1016=712%:%
+%:%1017=712%:%
+%:%1018=713%:%
+%:%1021=716%:%
+%:%1022=717%:%
+%:%1023=718%:%
+%:%1026=719%:%
+%:%1027=720%:%
+%:%1028=720%:%
+%:%1029=721%:%
+%:%1030=722%:%
+%:%1031=723%:%
+%:%1032=724%:%
+%:%1035=725%:%
+%:%1036=726%:%
+%:%1037=726%:%
+%:%1038=727%:%
+%:%1039=728%:%
+%:%1040=729%:%
+%:%1041=730%:%
+%:%1044=731%:%
+%:%1047=732%:%
+%:%1048=733%:%
+%:%1049=733%:%
+%:%1050=734%:%
+%:%1053=737%:%
+%:%1054=738%:%
+%:%1055=739%:%
+%:%1056=739%:%
+%:%1057=740%:%
+%:%1060=743%:%
+%:%1063=744%:%
+%:%1068=745%:%
\ No newline at end of file
diff --git a/lib/regfp.sail b/lib/regfp.sail
index 6044e1cc..ce361cd6 100644
--- a/lib/regfp.sail
+++ b/lib/regfp.sail
@@ -1,3 +1,6 @@
+$ifndef _REGFP
+$define _REGFP
+
 /* iR : input registers,
  * oR : output registers,
  * aR : registers feeding into the memory address */
@@ -110,3 +113,30 @@ union instruction_kind = {
   IK_simple : unit,
   IK_cache_op : cache_op_kind
 }
+
+val __read_mem
+  = { ocaml: "Platform.read_mem", c: "platform_read_mem", _: "read_mem" }
+  : forall 'n 'addrsize, 'n > 0 & 'addrsize in {32, 64}. (read_kind, int('addrsize), bits('addrsize), int('n)) -> bits(8 * 'n) effect {rmem}
+val __write_mem_ea
+  = { ocaml: "Platform.write_mem_ea", c: "platform_write_mem_ea", _: "write_mem_ea" }
+  : forall 'n 'addrsize, 'n > 0 & 'addrsize in {32, 64}. (write_kind, int('addrsize), bits('addrsize), int('n)) -> unit effect {eamem}
+val __write_mem
+  = { ocaml: "Platform.write_mem", c: "platform_write_mem", _: "write_mem" }
+  : forall 'n 'addrsize, 'n > 0 & 'addrsize in {32, 64}. (write_kind, int('addrsize), bits('addrsize), int('n), bits(8 * 'n)) -> bool effect {wmv}
+val __excl_res
+  = { ocaml: "Platform.excl_res", c: "platform_excl_res", _: "excl_res" }
+  : unit -> bool effect {exmem}
+val __barrier
+  = { ocaml: "Platform.barrier", c: "platform_barrier", _: "barrier" }
+  : barrier_kind -> unit effect {barr}
+
+
+/*
+val __write : forall 'n, 'n > 0. (write_kind, bits(64), int('n), bits(8 * 'n)) -> bool effect {eamem,wmv}
+function __write (wk, addr, len, value) = {
+  __write_mem_ea(wk, addr, len);
+  __write_mem(wk, addr, len, value)
+}
+*/
+
+$endif
diff --git a/lib/rts.c b/lib/rts.c
index fea3588d..dfb2ba5a 100644
--- a/lib/rts.c
+++ b/lib/rts.c
@@ -277,6 +277,60 @@ void read_ram(lbits *data,
   mpz_clear(byte);
 }
 
+void platform_read_mem(lbits *data,
+                       const int read_kind,
+                       const uint64_t addr_size,
+                       const sbits addr,
+                       const mpz_t n)
+{
+    mpz_t mpz_addr_size;
+    mpz_init(mpz_addr_size);
+    mpz_set_ui(mpz_addr_size, addr_size);
+    mpz_t addr_bv;
+    mpz_init(addr_bv);
+    mpz_set_ui(addr_bv, addr.bits);
+    read_ram(data, mpz_addr_size, n, (lbits){.len=0, .bits=NULL}, (lbits){.len=addr.len, .bits=&addr_bv});
+    mpz_clear(mpz_addr_size);
+    mpz_clear(addr_bv);
+}
+
+unit platform_write_mem_ea(const int write_kind,
+                           const uint64_t addr_size,
+                           const sbits addr,
+                           const mpz_t n)
+{
+    return UNIT;
+}
+
+bool platform_write_mem(const int write_kind,
+                        const uint64_t addr_size,
+                        const sbits addr,
+                        const mpz_t n,
+                        const lbits data)
+{
+    mpz_t mpz_addr_size;
+    mpz_init(mpz_addr_size);
+    mpz_set_ui(mpz_addr_size, addr_size);
+    mpz_t addr_bv;
+    mpz_init(addr_bv);
+    mpz_set_ui(addr_bv, addr.bits);
+    bool res = write_ram(mpz_addr_size, n, (lbits){.len=0, .bits=NULL}, (lbits){.len=addr.len, .bits=&addr_bv}, data);
+    mpz_clear(mpz_addr_size);
+    mpz_clear(addr_bv);
+    return res;
+}
+
+bool platform_excl_res(const unit unit)
+{
+    return true;
+}
+
+unit platform_barrier(const int barrier_kind)
+{
+    return UNIT;
+}
+
+
 unit load_raw(fbits addr, const sail_string file)
 {
   FILE *fp = fopen(file, "r");
diff --git a/lib/rts.h b/lib/rts.h
index c7c1259f..2c0722a6 100644
--- a/lib/rts.h
+++ b/lib/rts.h
@@ -71,6 +71,25 @@ sbits fast_read_ram(const int64_t data_size,
 unit write_tag_bool(const fbits, const bool);
 bool read_tag_bool(const fbits);
 
+void platform_read_mem(lbits *data,
+                       const int read_kind,
+                       const uint64_t addr_size,
+                       const sbits addr,
+                       const mpz_t n);
+unit platform_write_mem_ea(const int write_kind,
+                           const uint64_t addr_size,
+                           const sbits addr,
+                           const mpz_t n);
+bool platform_write_mem(const int write_kind,
+                        const uint64_t addr_size,
+                        const sbits addr,
+                        const mpz_t n,
+                        const lbits data);
+bool platform_excl_res(const unit unit);
+unit platform_barrier(const int barrier_kind);
+
+
+
 unit load_raw(fbits addr, const sail_string file);
 
 void load_image(char *);
diff --git a/lib/sail.h b/lib/sail.h
index dd3431f3..05c65027 100644
--- a/lib/sail.h
+++ b/lib/sail.h
@@ -381,6 +381,7 @@ void string_length(sail_int *len, sail_string s);
 void string_drop(sail_string *dst, sail_string s, sail_int len);
 void string_take(sail_string *dst, sail_string s, sail_int len);
 
+
 /* ***** Printing ***** */
 
 void string_of_int(sail_string *str, const sail_int i);
diff --git a/lib/smt.sail b/lib/smt.sail
index 4d250bef..f58c008f 100644
--- a/lib/smt.sail
+++ b/lib/smt.sail
@@ -6,6 +6,7 @@ $define _SMT
 /*! Euclidean division */
 val ediv_int = {
   ocaml: "quotient",
+  interpreter: "quotient",
   lem: "integerDiv",
   c: "ediv_int",
   coq: "ediv_with_eq"
@@ -13,6 +14,7 @@ val ediv_int = {
 
 val emod_int = {
   ocaml: "modulus",
+  interpreter: "modulus",
   lem: "integerMod",
   c: "emod_int",
   coq: "emod_with_eq"
@@ -20,6 +22,7 @@ val emod_int = {
 
 val abs_int = {
   ocaml: "abs_int",
+  interpreter: "abs_int",
   lem: "abs_int",
   c: "abs_int",
   coq: "abs_with_eq"
diff --git a/lib/vector_dec.sail b/lib/vector_dec.sail
index 746d29c6..ee84087e 100644
--- a/lib/vector_dec.sail
+++ b/lib/vector_dec.sail
@@ -7,6 +7,7 @@ type bits ('n : Int) = vector('n, dec, bit)
 
 val eq_bits = {
   ocaml: "eq_list",
+  interpreter: "eq_list",
   lem: "eq_vec",
   c: "eq_bits",
   coq: "eq_vec"
@@ -28,6 +29,7 @@ val bitvector_length = {coq: "length_mword", _:"length"} : forall 'n. bits('n) -
 
 val vector_length = {
   ocaml: "length",
+  interpreter: "length",
   lem: "length_list",
   c: "length",
   coq: "vec_length"
@@ -48,6 +50,7 @@ THIS`(v, n)` truncates `v`, keeping only the _least_ significant `n` bits.
  */
 val truncate = {
   ocaml: "vector_truncate",
+  interpreter: "vector_truncate",
   lem: "vector_truncate",
   coq: "vector_truncate",
   c: "sail_truncate"
@@ -69,7 +72,7 @@ function sail_mask(len, v) = if len <= length(v) then truncate(v, len) else sail
 
 overload operator ^ = {sail_mask}
 
-val bitvector_concat = {ocaml: "append", lem: "concat_vec", c: "append", coq: "concat_vec"} : forall ('n : Int) ('m : Int).
+val bitvector_concat = {ocaml: "append", interpreter: "append", lem: "concat_vec", c: "append", coq: "concat_vec"} : forall ('n : Int) ('m : Int).
   (bits('n), bits('m)) -> bits('n + 'm)
 
 overload append = {bitvector_concat}
@@ -79,6 +82,7 @@ val "append_64" : forall 'n. (bits('n), bits(64)) -> bits('n + 64)
 
 val bitvector_access = {
   ocaml: "access",
+  interpreter: "access",
   lem: "access_vec_dec",
   coq: "access_vec_dec",
   c: "vector_access"
@@ -86,6 +90,7 @@ val bitvector_access = {
 
 val plain_vector_access = {
   ocaml: "access",
+  interpreter: "access",
   lem: "access_list_dec",
   coq: "vec_access_dec",
   c: "vector_access"
@@ -95,6 +100,7 @@ overload vector_access = {bitvector_access, plain_vector_access}
 
 val bitvector_update = {
   ocaml: "update",
+  interpreter: "update",
   lem: "update_vec_dec",
   coq: "update_vec_dec",
   c: "vector_update"
@@ -102,6 +108,7 @@ val bitvector_update = {
 
 val plain_vector_update = {
   ocaml: "update",
+  interpreter: "update",
   lem: "update_list_dec",
   coq: "vec_update_dec",
   c: "vector_update"
@@ -111,6 +118,7 @@ overload vector_update = {bitvector_update, plain_vector_update}
 
 val add_bits = {
   ocaml: "add_vec",
+  interpreter: "add_vec",
   lem: "add_vec",
   c: "add_bits",
   coq: "add_vec"
@@ -118,6 +126,7 @@ val add_bits = {
 
 val add_bits_int = {
   ocaml: "add_vec_int",
+  interpreter: "add_vec_int",
   lem: "add_vec_int",
   c: "add_bits_int",
   coq: "add_vec_int"
@@ -134,16 +143,29 @@ val sub_bits = {
 
 val not_vec = {c: "not_bits", _: "not_vec"} : forall 'n. bits('n) -> bits('n)
 
-val and_vec = {lem: "and_vec", c: "and_bits", coq: "and_vec", ocaml: "and_vec"} : forall 'n. (bits('n), bits('n)) -> bits('n)
+val and_vec = {
+  lem: "and_vec",
+  c: "and_bits",
+  coq: "and_vec",
+  ocaml: "and_vec",
+  interpreter: "and_vec"
+} : forall 'n. (bits('n), bits('n)) -> bits('n)
 
 overload operator & = {and_vec}
 
-val or_vec = {lem: "or_vec", c: "or_bits", coq: "or_vec", ocaml: "or_vec"} : forall 'n. (bits('n), bits('n)) -> bits('n)
+val or_vec = {
+  lem: "or_vec",
+  c: "or_bits",
+  coq: "or_vec",
+  ocaml: "or_vec",
+  interpreter: "or_vec"
+} : forall 'n. (bits('n), bits('n)) -> bits('n)
 
 overload operator | = {or_vec}
 
 val vector_subrange = {
   ocaml: "subrange",
+  interpreter: "subrange",
   lem: "subrange_vec_dec",
   c: "vector_subrange",
   coq: "subrange_vec_dec"
@@ -152,6 +174,7 @@ val vector_subrange = {
 
 val vector_update_subrange = {
   ocaml: "update_subrange",
+  interpreter: "update_subrange",
   lem: "update_subrange_vec_dec",
   c: "vector_update_subrange",
   coq: "update_subrange_vec_dec"
diff --git a/lib/vector_inc.sail b/lib/vector_inc.sail
index 581dded7..daba99be 100644
--- a/lib/vector_inc.sail
+++ b/lib/vector_inc.sail
@@ -9,6 +9,7 @@ val "eq_bit" : (bit, bit) -> bool
 
 val eq_bits = {
   ocaml: "eq_list",
+  interpreter: "eq_list",
   lem: "eq_vec",
   c: "eq_bits",
   coq: "eq_vec"
@@ -20,6 +21,7 @@ val bitvector_length = {coq: "length_mword", _:"length"} : forall 'n. bits('n) -
 
 val vector_length = {
   ocaml: "length",
+  interpreter: "length",
   lem: "length_list",
   c: "length",
   coq: "length_list"
@@ -37,6 +39,7 @@ val "zero_extend" : forall 'n 'm, 'm >= 'n. (bits('n), atom('m)) -> bits('m)
 
 val truncate = {
   ocaml: "vector_truncate",
+  interpreter: "vector_truncate",
   lem: "vector_truncate",
   coq: "vector_truncate",
   c: "truncate"
@@ -48,7 +51,7 @@ function mask(len, v) = if len <= length(v) then truncate(v, len) else zero_exte
 
 overload operator ^ = {mask}
 
-val bitvector_concat = {ocaml: "append", lem: "concat_vec", c: "append", coq: "concat_vec"} : forall ('n : Int) ('m : Int).
+val bitvector_concat = {ocaml: "append", interpreter: "append", lem: "concat_vec", c: "append", coq: "concat_vec"} : forall ('n : Int) ('m : Int).
   (bits('n), bits('m)) -> bits('n + 'm)
 
 overload append = {bitvector_concat}
@@ -58,6 +61,7 @@ val "append_64" : forall 'n. (bits('n), bits(64)) -> bits('n + 64)
 
 val bitvector_access = {
   ocaml: "access",
+  interpreter: "access",
   lem: "access_vec_inc",
   coq: "access_vec_inc",
   c: "vector_access"
@@ -65,6 +69,7 @@ val bitvector_access = {
 
 val plain_vector_access = {
   ocaml: "access",
+  interpreter: "access",
   lem: "access_list_inc",
   coq: "access_list_inc",
   c: "vector_access"
@@ -74,6 +79,7 @@ overload vector_access = {bitvector_access, plain_vector_access}
 
 val bitvector_update = {
   ocaml: "update",
+  interpreter: "update",
   lem: "update_vec_inc",
   coq: "update_vec_inc",
   c: "vector_update"
@@ -81,6 +87,7 @@ val bitvector_update = {
 
 val plain_vector_update = {
   ocaml: "update",
+  interpreter: "update",
   lem: "update_list_inc",
   coq: "update_list_inc",
   c: "vector_update"
@@ -90,11 +97,12 @@ overload vector_update = {bitvector_update, plain_vector_update}
 
 val add_bits = {
   ocaml: "add_vec",
+  interpreter: "add_vec",
   c: "add_bits"
 } : forall 'n. (bits('n), bits('n)) -> bits('n)
 
 val add_bits_int = {
-  ocaml: "add_vec_int",
+  ocaml: "add_vec_int", interpreter: "add_vec_int",
   c: "add_bits_int"
 } : forall 'n. (bits('n), int) -> bits('n)
 
@@ -102,6 +110,7 @@ overload operator + = {add_bits, add_bits_int}
 
 val vector_subrange = {
   ocaml: "subrange",
+  interpreter: "subrange",
   lem: "subrange_vec_inc",
   c: "vector_subrange",
   coq: "subrange_vec_inc"
@@ -110,6 +119,7 @@ val vector_subrange = {
 
 val vector_update_subrange = {
   ocaml: "update_subrange",
+  interpreter: "update_subrange",
   lem: "update_subrange_vec_inc",
   c: "vector_update_subrange",
   coq: "update_subrange_vec_inc"